力扣刷题 - 数组篇

news2024/11/25 0:45:53

这里写目录标题

  • 数组的遍历
    • 485
    • 495
    • 414
    • 628
  • 统计数组中的元素
  • 645
  • 697
  • 448
  • 442
  • 41
  • 数组的改变与移动
    • 453
    • 665---
    • 283
  • 二维数组以及滚动数组
    • 118
    • 119
    • 661
    • 419---
  • 数组的旋转
    • 189
    • 396
  • 特定顺序遍历二维数组
    • 54
    • 59
    • 498
  • 二维数组的变换
    • 566
    • 48
    • 73---
  • 前缀和数组
    • 303
    • 238
    • 506

数组的遍历

485

https://leetcode.cn/problems/max-consecutive-ones/

在这里插入图片描述
暴力解法: 定义一个变量来统计是否连续

public int findMaxConsecutiveOnes(int[] nums) {
        int max=0;
        int count=0;
        for(int i=0; i < nums.length ;i++){
            if(nums[i] == 1){
                count++;
                if(max < count){
                    max = count;

                }
            }else{
                count=0;
            }
        }
        return max;
    }

495

https://leetcode.cn/problems/teemo-attacking/

在这里插入图片描述
暴力解法: 记录每次中的开始时间与结束时间, 然后如果下一次中毒的是在结束时间之前, 就去更新开始时间(让它加上这个持续时间减去结束时间),如果是在之后,直接加上持续时间

public int findPoisonedDuration(int[] timeSeries, int duration) {
        int ans = 0;//开始时间
        int expired = 0;//结束时间
        for (int i = 0; i < timeSeries.length; ++i) {
            if (timeSeries[i] >= expired) {
                ans += duration;
            } else {
                ans += timeSeries[i] + duration - expired;
            }
            expired = timeSeries[i] + duration;
        }
        return ans;
    }

414

在这里插入图片描述
注意，要求返回第三大的数，是指在所有不同数字中排第三大的数。
此例中存在两个值为 2 的数，它们都排第二。在所有不同数字中排第三大的数为 1 。
解法1 : 数组排序, 然后用哈希表找出不同数字中的第三大的数

public int thirdMax(int[] nums) {
        
        Arrays.sort(nums);
        if (nums.length < 3){
            return nums[nums.length-1];
        }
        HashSet<Integer> set=new HashSet<>();
        int k=0;
        int max=0;
        for (int i = nums.length-1; i >=0 ; i--) {
            if (!set.contains(nums[i])){
                
                set.add(nums[i]);
                k++;
                if (k == 3){
                    max=nums[i];
                    break;
                }
            }
        }
        if(k < 3){
            return nums[nums.length-1];
        }
        return max;
    }

解法2 : 用一个有序集合来维护数组中前三大的数。具体做法是每遍历一个数，就将其插入有序集合，若有序集合的大小超过 3，就删除集合中的最小元素。这样可以保证有序集合的大小至多为 3，且遍历结束后，若有序集合的大小为 3，其最小值就是数组中第三大的数；若有序集合的大小不足 3，那么就返回有序集合中的最大值。

public int thirdMax(int[] nums) {
        TreeSet<Integer> s = new TreeSet<Integer>();
        for (int num : nums) {
            s.add(num);
            if (s.size() > 3) {
                s.remove(s.first());
            }
        }
        return s.size() == 3 ? s.first() : s.last();
    }

628

https://leetcode.cn/problems/maximum-product-of-three-numbers/

在这里插入图片描述
解法1: 排序, 将数组排好序然后算乘积即可
如果数组中全是正数或全是负数，则排序后最大的三个数相乘即为最大乘积；

如果数组中有正数有负数，则最大乘积既可能是三个最大正数的乘积，也可能是两个最小负数（即绝对值最大）与最大正数的乘积。

public int maximumProduct(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        return Math.max(nums[0] * nums[1] * nums[n - 1], nums[n - 3] * nums[n - 2] * nums[n - 1]);
    }

第二种解法: 利用5个变量找出, 最大的三个数以及最小的两个数

统计数组中的元素

645

https://leetcode.cn/problems/set-mismatch/

在这里插入图片描述
解法:该题型都是一种解法,就是将 i位置上的数 换成 i+1 的数, 这个是已经按这种规律弄好了的,所以我们直接找就行了,如果是无序的就需要我们遍历弄成这种结构

public int[] findErrorNums(int[] nums) {
        int[] arr=new int[2];
        for (int i = 0; i <= nums.length-1; i++) {
            if (i+1 != nums[i]){
                arr[0]=i;
                arr[1]=i+1 > nums[i]?i+1:nums[i];
                break;
            }
        }
        return arr;
    }

697

https://leetcode.cn/problems/degree-of-an-array/

在这里插入图片描述
题的意思就是: 包含最小度的连续子数组的长度是多少
暴力解法: 枚举所有可能性,然后得出最小连续子数组长度多少
解法1:利用哈希表来存放, 子数组的长度以及次数

public int findShortestSubArray(int[] nums) {
        /*用的是Integer和数组定义的
        * 0代表出现次数,1代表出现起始位置,2代表最终位置*/
        Map<Integer, int[]> map = new HashMap<Integer, int[]>();
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (map.containsKey(nums[i])) {
                map.get(nums[i])[0]++;
                map.get(nums[i])[2] = i;
            } else {
                map.put(nums[i], new int[]{1, i, i});
            }
        }
        int maxNum = 0, minLen = 0;
        /*max代表最大次数,min最小长度*/
        for (Map.Entry<Integer, int[]> entry : map.entrySet()) {
            int[] arr = entry.getValue();
            if (maxNum < arr[0]) {
                maxNum = arr[0];
                minLen = arr[2] - arr[1] + 1;
            } else if (maxNum == arr[0]) {
                if (minLen > arr[2] - arr[1] + 1) {
                    minLen = arr[2] - arr[1] + 1;
                }
            }
        }
        return minLen;
    }

448

在这里插入图片描述
解法: 同样的让i位置上的数等于 i+1,不等的就是消失的数了
这个重点是下面的修改操作,建议背会

 public  static List<Integer> findDisappearedNumbers(int[] nums) {
        List<Integer> list = new ArrayList<>();
        for (int val:nums) {
            modify(val,nums);
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != i+1){
                list.add(i+1);
            }
        }
        return list;
    }
    private static void modify(int val, int[] arr) {
        while (arr[val-1] != val){
            int tmp = arr[val-1];
            arr[val-1] = val;
            val =tmp;
        }
    }

解法2:利用哈希表记录

public List<Integer> findDisappearedNumbers(int[] nums) {
        List<Integer> list=new LinkedList<>();
        HashMap<Integer,Integer> hashMap=new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            hashMap.put(nums[i],hashMap.getOrDefault(nums[i],0)+1);
        }
        for (int i = 1; i <= nums.length; i++) {
            if (!hashMap.containsKey(i)){
                list.add(i);
            }
        }
        return list;
    }

442

在这里插入图片描述
解法: nums[i] 加上「负号」表示数 i+1 已经出现过一次。具体地，我们首先对数组进行一次遍历。当遍历到位置 i 时，我们考虑 nums[nums[i]−1的正负性：

public List<Integer> findDuplicates(int[] nums) {
        int n = nums.length;
        List<Integer> ans = new ArrayList<Integer>();
        for (int i = 0; i < n; ++i) {
            int x = Math.abs(nums[i]);
            if (nums[x - 1] > 0) {
                nums[x - 1] = -nums[x - 1];
            } else {
                ans.add(x);
            }
        }
        return ans;
    }

41

在这里插入图片描述对数组进行一次遍历，对于遍历到的数 x=nums[i] 如果 x∈[1,N]我们就知道 x 应当出现在数组中的 x−1 的位置，因此交换 nums[i] 和 nums[x−1]，这样 xxx 就出现在了正确的位置。在完成交换后，新的 nums[i]可能还在 [1,N]的范围内，我们需要继续进行交换操作，直到 x∉[1,N]

注意到上面的方法可能会陷入死循环。如果 nums[i] 恰好与 nums[x−1]\textit{nums}[x - 1]nums[x−1] 相等，那么就会无限交换下去。此时我们有 nums[i]=x=nums[x−1]说明 x 已经出现在了正确的位置。因此我们可以跳出循环，开始遍历下一个数。

解法:

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;
            }
        }
        for (int i = 0; i < n; ++i) {
            if (nums[i] != i + 1) {
                return i + 1;
            }
        }
        return n + 1;
    }

数组的改变与移动

453

在这里插入图片描述
有一个规律叫做,正难反易 , 正面将数组加到一个相等的状况比较难, 所以我们考虑如何让数组减小到一个最小值
我们可以轻易得到, 每个数与相对最小值的次数,就是它的最小操作次数

public int minMoves(int[] nums) {
        int minNum = Arrays.stream(nums).min().getAsInt();
        int res = 0;
        for (int num : nums) {
            res += num - minNum;
        }
        return res;
    }

665—

在这里插入图片描述
解法 : 将遇到的第一个非递减的数,改变然后继续观察

public boolean checkPossibility(int[] nums) {
        int n = nums.length, cnt = 0;
        for (int i = 0; i < n - 1; ++i) {
            int x = nums[i], y = nums[i + 1];
            if (x > y) {
                cnt++;
                if (cnt > 1) {
                    return false;
                }
                if (i > 0 && y < nums[i - 1]) {
                    nums[i + 1] = x;
                }
            }
        }
        return true;
    }

283

在这里插入图片描述
解法: 利用双指针right是不等于0的数,每次遇到不等于的数就将这个数挪到前面

 public void moveZeroes(int[] nums) {
        int n = nums.length, left = 0, right = 0;
        while (right < n) {
            if (nums[right] != 0) {
                swap(nums, left, right);
                left++;
            }
            right++;
        }
    }

    public void swap(int[] nums, int left, int right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }

二维数组以及滚动数组

118

在这里插入图片描述

class Solution {
      public List<List<Integer>> generate(int rowIndex) {
             List<List<Integer>> C = new ArrayList<List<Integer>>();
        for (int i = 0; i < rowIndex; ++i) {
            List<Integer> row = new ArrayList<Integer>();
            for (int j = 0; j <= i; ++j) {
                if (j == 0 || j == i) {
                    row.add(1);
                } else {
                    row.add(C.get(i - 1).get(j - 1) + C.get(i - 1).get(j));
                }
            }
            C.add(row);
        }
        return C;
    }

}

119

在这里插入图片描述

 public List<Integer> getRow(int rowIndex) {
        List<List<Integer>> C = new ArrayList<List<Integer>>();
        for (int i = 0; i <= rowIndex; ++i) {
            List<Integer> row = new ArrayList<Integer>();
            for (int j = 0; j <= i; ++j) {
                if (j == 0 || j == i) {
                    row.add(1);
                } else {
                    row.add(C.get(i - 1).get(j - 1) + C.get(i - 1).get(j));
                }
            }
            C.add(row);
        }
        return C.get(rowIndex);
    }

661

在这里插入图片描述
在这里插入图片描述
题解: 第一种暴力枚举

public int[][] imageSmoother(int[][] img) {
        int m = img.length, n = img[0].length;
        int[][] ret = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int num = 0, sum = 0;
                for (int x = i - 1; x <= i + 1; x++) {
                    for (int y = j - 1; y <= j + 1; y++) {
                        if (x >= 0 && x < m && y >= 0 && y < n) {
                            num++;
                            sum += img[x][y];
                        }
                    }
                }
                ret[i][j] = sum / num;
            }
        }
        return ret;
    }

第二种:利用前缀和的思想 ,求每个i位置的的和
二维前缀和模板
在这里插入图片描述

for(int i = 1; i <= n; i++)
 for(int j = 1; j <= m; j++)
 dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + arr[i][j];

public int[][] imageSmoother(int[][] img) {
        int m = img.length, n = img[0].length;
        int[][] sum = new int[m + 10][n + 10];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + img[i - 1][j - 1];
            }
        }
        int[][] ans = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int a = Math.max(0, i - 1), b = Math.max(0, j - 1);
                int c = Math.min(m - 1, i + 1), d = Math.min(n - 1, j + 1);
                int cnt = (c - a + 1) * (d - b + 1);
                int tot = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b];
                ans[i][j] = tot / cnt;
            }
        }
        return ans;
    }

419—

在这里插入图片描述

在这里插入图片描述
解法: 深度优先遍历

class Solution {
    static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    int m, n;
    char[][] board;
    boolean[][] visited;

    public int countBattleships(char[][] board) {
        int battleships = 0;
        this.m = board.length;
        this.n = board[0].length;
        this.board = board;
        this.visited = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == '.' || visited[i][j]) {
                    continue;
                }
                battleships++;
                dfs(i, j);
            }
        }
        return battleships;
    }

    public void dfs(int row, int col) {
        visited[row][col] = true;
        for (int[] dir : dirs) {
            int newRow = row + dir[0], newCol = col + dir[1];
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && board[newRow][newCol] == 'X' && !visited[newRow][newCol]) {
                dfs(newRow, newCol);
            }
        }
    }
}

数组的旋转

189

在这里插入图片描述

 public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] newArr = Arrays.copyOf(nums,nums.length);
        for (int i = 0; i < n; ++i) {
            nums[(i + k) % n] = newArr[i];
        }
    }

396

在这里插入图片描述

class Solution {
   public int maxRotateFunction(int[] nums) {
        int f = 0, n = nums.length, numSum = Arrays.stream(nums).sum();
        for (int i = 0; i < n; i++) {
            f += i * nums[i];
        }
        int res = f;
        for (int i = n - 1; i > 0; i--) {
            f += numSum - n * nums[i];
            res = Math.max(res, f);
        }
        return res;
    }
}

特定顺序遍历二维数组

54

在这里插入图片描述
解法: 用特定的黑盒来遍历一个框架,每次传过去一个框架就行了

 public List<Integer> spiralOrder(int[][] matrix) {
        int x1 =0 ,y1=0;
        int x2 =matrix.length-1,y2=matrix[0].length-1;
        List<Integer> list = new ArrayList<>();
        while (x1 <= x2 && y1 <= y2){
            process1(matrix,x1,y1,x2,y2,list);
            x1++;y1++;
            x2--;y2--;
        }
        return list;
    }
    private static void process1(int[][] arr, int x1,int y1,int x2, int y2,List<Integer> list){
        for (int i = y1; i <= y2; i++) {
           list.add(arr[x1][i]);
        }
        for (int i = x1+1; i <= x2; i++) {
            list.add(arr[i][y2]);
        }
        // 最后俩个要注意一下细节问题, 因为如果行与列不一致的话,很可能会重复,要进过判断去重
         for (int i = y2-1; i >= y1&& x1 != x2; i--) {
            list.add(arr[x2][i]);
        }
        for (int i = x2-1; i > x1 && y1 != y2; i--) {
            list.add(arr[i][y1]);
        }
    }

59

在这里插入图片描述

 public int[][] generateMatrix(int n) {

        if (n <= 0){
            return null;
        }
        int[][] array=new int[n][n];
        int left = 0;
        int right = n-1;
        int top = 0;
        int bottom = n-1;
        int numEle = 1;

        while (numEle <= n*n){
            for (int i = left; i <= right && numEle <= n*n; i++) {
                array[top][i]=numEle;
                numEle++;
            }
            top++;
            for (int i = top; i <= bottom && numEle <= n*n ; i++) {
                array[i][right]=numEle;
                numEle++;
            }
            right--;
            for (int i = right; i >= left && numEle <= n*n; i--) {
                array[bottom][i]=numEle;
                numEle++;
            }
            bottom--;
            for (int i = bottom; i >= top && numEle <= n*n; i--) {
                  array[i][left]=numEle;
                numEle++;
            }
            left++;
        }
        return array;
    }

498

在这里插入图片描述

// // 斜的方式打印
    public static void printMatrZigzag(int[][] arr){
        int ar=0,ac=0,br=0,bc=0;
        int endR = arr.length-1;
        int endC = arr[0].length-1;
        boolean from = false;
        while (ar != endR+1){
            printLevel(arr,ar,ac,br,bc,from);
            ar=ac == endC?ar+1:ar;// a到了最后一列 a的行才增加
            ac= ac == endC?ac:ac+1;// a的列到了最后一列才不变, 否则就增加
            bc = br == endR?bc+1:bc;
            br =br == endR?br:br+1;
            from =!from;
        }
        System.out.println();
    }

    private static void printLevel(int[][] arr, int tr, int tc, int dr, int dc, boolean from) {
        if (from){
            while (tr != dr+1) System.out.println(arr[tr++][tc--]+" ");
        }else {
            while (dr != tr-1){
                System.out.println(arr[dr--][dc++]+" ");
            }
        }

    }

二维数组的变换

566

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

class Solution {
      public int[][] matrixReshape(int[][] nums, int r, int c) {
        int m = nums.length;
        int n = nums[0].length;
        if (m * n != r * c) {
            return nums;
        }

        int[][] ans = new int[r][c];
        for (int x = 0; x < m * n; ++x) {
            ans[x / c][x % c] = nums[x / n][x % n];
        }
        return ans;
    }
}

48

在这里插入图片描述

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

}

73—

在这里插入图片描述
解法: 先判断第一行和第一列有没有0,然后用其他列来处理第一行和第一列,最后更新第一行和第一列

class Solution {
  public void setZeroes(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        boolean flagCol0 = false, flagRow0 = false;
        for (int i = 0; i < m; i++) {
            if (matrix[i][0] == 0) {
                flagCol0 = true;
            }
        }
        for (int j = 0; j < n; j++) {
            if (matrix[0][j] == 0) {
                flagRow0 = true;
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] == 0) {
                    matrix[i][0] = matrix[0][j] = 0;
                }
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }
        if (flagCol0) {
            for (int i = 0; i < m; i++) {
                matrix[i][0] = 0;
            }
        }
        if (flagRow0) {
            for (int j = 0; j < n; j++) {
                matrix[0][j] = 0;
            }
        }
    }
}

前缀和数组

前缀和思想 - 快速求出数组中某一段连续区间的和
第一步: 先预处理来一个前缀和数组
dp[i]表示[1,i]所有元素的和
第二部: 求某一段的和就是用大的长度减去小的长度
在这里插入图片描述
在这里插入图片描述

import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
 public static void main(String[] args) {
     Scanner in = new Scanner(System.in);
     int n = in.nextInt();
     int m = in.nextInt();
     int q = in.nextInt();
     int[][] arr = new int[n + 1][m + 1];
     long[][] dp = new long[n + 1][m + 1];
     // 读⼊数据
     for(int i = 1; i <= n; i++)
     for(int j = 1; j <= m; j++)
     arr[i][j] = in.nextInt();
 
 // 处理前缀和矩阵
 for(int i = 1; i <= n; i++)
 for(int j = 1; j <= m; j++)
 dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + arr[i][j];
 while(q > 0)
 {
    int x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
     System.out.println(dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1]);
     q--;
 }
 }
 }

303

在这里插入图片描述

import java.util.*;
class NumArray {
    int[]  array=null;
    public NumArray(int[] nums) {
        array= Arrays.copyOf(nums,nums.length);
    }
    
    public int sumRange(int left, int right) {
        int sum=0;
        for (int i = left; i <= right; i++) {
            sum+=array[i];
        }
        return sum;
    }
}

238

在这里插入图片描述

class Solution {
  public int[] productExceptSelf(int[] nums) {
      int n  = nums.length;
        int[] pre = new int[n];
        int[] post = new int[n];
        // 细节问题  首尾是 1 不是 0
        post[n-1] = 1;pre[0]=1;
        for(int i =1 ;i < n;i++){
            pre[i]=pre[i-1]*nums[i-1];
        }
        for(int i = n-2 ; i >= 0 ;i-- ){
            post[i] = post[i+1]*nums[i+1];
        }
        int[] ans = new int[n];
        for(int i=0;i < n ; i++){
            ans[i] = pre[i]*post[i];
        }
        return ans;
  }
}

506

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

public int subarraySum(int[] nums, int k) {
        int sum =0;
        HashMap<Integer,Integer> map = new HashMap<>();
        map.put(0,1);
        int ret=0;
        for(int i =0;i< nums.length;i++){
            sum+= nums[i];
            ret+=map.getOrDefault(sum-k,0);
            map.put(sum,map.getOrDefault(sum,0)+1);
        }
        return ret;
    }

在这里插入图片描述
同余定理: 如果 (a - b) % n == 0 ，那么我们可以得到⼀个结论： a % n == b % n
如果出现负数情况下:怎么修正
在这里插入图片描述

  public int subarraysDivByK(int[] nums, int k) {
        int sum=0,ret=0;
        Map<Integer,Integer> map = new HashMap<>();
        map.put(0%k,1);
        for (int i = 0; i < nums.length; i++) {
            sum+=nums[i];
            int r = (sum%k+k)%k;
            ret+=map.getOrDefault(r,0);
            map.put(r,map.getOrDefault(r,0)+1);
        }
        return ret;
    }

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

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

相关文章

【HCIA】07.OSPF

【HCIA】07.OSPF

动态路由的协议分类 按工作区域分&#xff1a; IGP&#xff08;内部网关协议 interior gateway protocols&#xff09;&#xff1a;OSPF、IS-IS、RIPEGP&#xff08;外部网关协议 exterior gateway protocols&#xff09;&#xff1a;BGP 按工作机制及算法分类&#xff1a; 距离…
阅读更多...
机器学习（12）--K-Means

机器学习（12）--K-Means

目录 一、聚类 二、机器学习中的距离 三、sklearn中的聚类算法 四、KMeans簇内平方和和时间复杂度 五、sklearn中的KMeans 1、建立一个数据集 2、使用K-Means进行聚类操作 3、根据上面的模型绘散点图观察分类效果。 4、评估指标 4.1对于真实标签已知情况 4.2当真实标…
阅读更多...
[RocketMQ] Broker 消息重放服务源码解析 (十三)

[RocketMQ] Broker 消息重放服务源码解析 (十三)

构建消息文件ConsumeQueue和IndexFile。 ConsumeQueue: 看作是CommitLog的消息偏移量索引文件, 存储了它所属Topic的消息在Commit Log中的偏移量。消费者拉取消息的时候, 可以从Consume Queue中快速的根据偏移量定位消息在Commit Log中的位置。IndexFile索引文件: 看作是Commi…
阅读更多...
【bash:xxx:command not found问题,在英伟达nvidia的jetson-orin-nx上遇到的＞＞＞解决方式之一】

【bash:xxx:command not found问题,在英伟达nvidia的jetson-orin-nx上遇到的＞＞＞解决方式之一】

【bash:xxx:command not found问题,在英伟达nvidia的jetson-orin-nx上遇到的>>>解决方式之一】 1、概述2、实验环境3、问题描述&#xff1a;bash:xxx:command not found问题4、我的努力第一种方式&#xff1a;加入指令方式第二种方式&#xff1a;使用echo $PATH命令查…
阅读更多...
设计模式（七）-----桥接模式（Bridge Pattern)

设计模式（七）-----桥接模式（Bridge Pattern)

目录 什么是桥接模式优点缺点应用场景 基本结构业务场景不使用模式的解决方案实现发送普通消息实现发送加急消息实现发送特急消息添加发送手机消息的处理方式 使用桥梁模式来解决问题 什么是桥接模式 将抽象部分与他的实现部分分离,这样抽象化与实现化解耦,使他们可以独立的变…
阅读更多...
Es直方图聚合--date_histogram

Es直方图聚合--date_histogram

文章目录 1、背景2、bucket_key如何计算3、前置知识4、日历和固定时间间隔 4.1 Calendar intervals 日历间隔4.2 Fixed intervals 固定间隔 5、数据准备 5.1 准备mapping5.2 准备数据 6、聚合案例 6.1 dsl6.2 java代码6.3 聚合结果 7、完整代码8、参考文档 1、背景 此处来简单学…
阅读更多...
云计算UPS监控，怎么办？

云计算UPS监控，怎么办？

在大型数据机房中&#xff0c;UPS系统扮演着关键的角色&#xff0c;为计算机和网络设备提供可靠的电力备份。由于数据机房的规模庞大且关键性强&#xff0c;监控UPS系统的可靠性和效率至关重要。 UPS监控可以提供实时的电池状态、负载信息、电网电压等监测数据&#xff0c;并能…
阅读更多...
c++中assert

c++中assert

参考:https://blog.csdn.net/bitcarmanlee/article/details/124283683 1.什么是assert assert&#xff0c;中文翻译为断言&#xff0c;注意是一个宏定义&#xff0c;不是函数。 c中&#xff0c;要使用assert&#xff0c;可以将cassert头文件include进来&#xff0c;而cassert最…
阅读更多...
路径规划算法：基于孔雀优化的路径规划算法- 附代码

路径规划算法：基于孔雀优化的路径规划算法- 附代码

路径规划算法&#xff1a;基于孔雀优化的路径规划算法- 附代码 文章目录 路径规划算法&#xff1a;基于孔雀优化的路径规划算法- 附代码1.算法原理1.1 环境设定1.2 约束条件1.3 适应度函数 2.算法结果3.MATLAB代码4.参考文献 摘要&#xff1a;本文主要介绍利用智能优化算法孔雀…
阅读更多...
【HCIA】09.STP

【HCIA】09.STP

STP的选举之发波原理 设备启动之后&#xff0c;经过选举会分别显示出它们的等级&#xff08;最强&#xff0c;次强&#xff0c;最弱&#xff09;选出等级之后&#xff0c;两两设备开始互相发波&#xff0c;等级强的设备会将弱的设备的光顶回去此时两两设备之间的波就是单方向的…
阅读更多...
家政服务小程序软件解决方案

家政服务小程序软件解决方案

家政服务小程序软件是近年来随着人们对家政服务需求的增长而逐渐兴起的一种数字化服务解决方案。通过小程序软件&#xff0c;用户可以轻松预约家政服务&#xff0c;包括保姆、月嫂、钟点工等&#xff0c;而且价格透明、服务规范&#xff0c;大大提高了用户对家政服务的满意度。…
阅读更多...
神经网络结构可视化-netron

神经网络结构可视化-netron

网址&#xff1a;https://netron.app/ 点选择模型&#xff0c;将oonx文件拉到netron界面&#xff0c;即可 输出; 如何将pytorch模型转换为onnx的格式&#xff1f; 在测试&#xff08;训练好的模型&#xff09;里输入代码 to_onnx(model, 3, 28, 28, output/params.onnx)其…
阅读更多...
【Linux】十分钟理解动静态库

【Linux】十分钟理解动静态库

目录 一 前置概念二 静态库2.12.22.3放入指定路径2.4 第三方库的使用 四 动态库3.1 环境变量3.2 软链接方案3.3 配置文件方案 一 前置概念 我们在VS2022下安装开发环境实际上就是安装编译器软件、安装要开发的语言配套的库和头文件。我们使用编译器有语法的自动提醒功能&#…
阅读更多...
python常用库之colorama (python命令行界面打印怎么加颜色)

python常用库之colorama (python命令行界面打印怎么加颜色)

文章目录 python常用库之colorama (python命令行界面打印怎么加颜色)背景colorama介绍colorama使用colorama打印红色闪烁打印颜色组合 python常用库之colorama (python命令行界面打印怎么加颜色) 背景 在Python开发项目过程中&#xff0c;为了方便调试代码&#xff0c;经常会…
阅读更多...
Java中Map中10w条数据用什么循环性能最好呢？

Java中Map中10w条数据用什么循环性能最好呢？

加油&#xff0c;新时代打工人&#xff01; 1、java中List集合三种获取集合元素方式 2、Java中Map使用增强for循环和迭代器获取key和value 选择合适的循环方式&#xff0c;让性能最优&#xff01; public class Test2 {public static void main(String[] args) {//初始化 10w…
阅读更多...
vue upload 上传下载

vue upload 上传下载

目录 上传 下载 对象/文件流 download处理返回 文件流 axios.post 封装axios 1.请求设置类型responseType: blob 2.若有请求拦截(直接返回即可) 3.download 4.请求下载 相关基础 blob MIME vue 实现文件上传、下载的方法 - 掘金 上传 submitAddFile(){var form…
阅读更多...
基础算法-【离散化】

基础算法-【离散化】

离散化的本质&#xff1a;是建立了一段数列到自然数之间的映射关系&#xff08;value -> index)&#xff0c;通过建立新索引&#xff0c;来缩小目标区间&#xff0c;使得可以进行一系列连续数组可以进行的操作比如二分&#xff0c;前缀和等… 相应的算法模板&#xff1a; v…
阅读更多...
【Linux】—— 进程地址空间

【Linux】—— 进程地址空间

序言&#xff1a; 在上篇中&#xff0c;我们讲解了关于进程优先级的概念。本期&#xff0c;我将给大家介绍的是关于进程地址空间的话题。 目录 &#xff08;一&#xff09;程序地址空间回顾 &#xff08;二&#xff09;代码演示 &#xff08;三&#xff09;进程地址空间的引…
阅读更多...
【力扣算法08】之 5. 最长回文子串 python

【力扣算法08】之 5. 最长回文子串 python

文章目录 问题描述示例1示例2提示 思路分析代码分析完整代码详细分析 运行效果截图调用示例运行结果 完结 问题描述 给你一个字符串 s&#xff0c;找到 s 中最长的回文子串。 如果字符串的反序与原始字符串相同&#xff0c;则该字符串称为回文字符串。 示例1 输入&#xff1a;s…
阅读更多...
【网络编程】Linux服务器程序规范相关内容

【网络编程】Linux服务器程序规范相关内容

文章目录 1、日志1.1、syslog()函数 2、用户信息2.1、UID、EUID、GID、EGID 3、进程间关系3.1、进程组3.2、会话 4、服务器程序后台化&#xff08;守护进程&#xff09; 1、日志 Linux提供一个守护进程rsyslogd来处理系统日志&#xff0c;系统日志中包括用户进程产生的日志以及…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023