分治策略 --- 快排归并

目录

分治-快排

一、颜色分类

二、排序数组

三、数组中的第K个最大元素

四、库存管理

分治-归并

一、排序数组

二、交易逆序对的总数

三、计算右侧小于当前元素的个数

四、翻转对

分治是一种思想，也就是将大问题分解成小问题，一直分到小问题可以快速被解决为止~

分治-快排

一、颜色分类

1.题目解析

包含三种颜色的数组，将同样的颜色分到一起，并且按红白蓝排序

2.算法分析

大家可以先复习一下我的第一篇博客双指针算法中的第一道题---移动零，本质就是数组分两块！

双指针算法-CSDN博客

而本题是要将数组分三块，所以相当于用"三指针"

下标的含义:

i: 遍历数组

left: 标记0区域的最右侧

right: 标记2区域的最左侧

过程分析:

nums[i] == 0 ：swap(nums[++left], nums[i++])

nums[i] == 1 ：++i

nums[i] == 2 :  swap(nums[--right], nums[i])

注意: num[i]==2时，交换完之后不能让i++, 因为我们不清楚nums[--right]的值是几，因此还要继续判断!

3.算法代码

class Solution {
public:
    void sortColors(vector<int>& nums) 
    {
        int i = 0, left = -1, right = nums.size();
        while(i < right)
        {
            if(nums[i] == 0) swap(nums[++left], nums[i++]);
            else if(nums[i] == 1) i++;
            else swap(nums[--right], nums[i]);
        }
    }
};

二、排序数组

912. 排序数组 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/sort-an-array/1.题目解析

排序数组，升序

2.算法分析

采用分治的思想解决，选择一个基准元素key, 使得左边比key小，右边比key大，然后分治子问题, 如果采用之前快排的方法，当数组元素全都相同时，时间复杂度会退化到O(n^2), 详细分析可以看我之前的博客:

排序素来美如玉，层进理解获芳心-CSDN博客

因此我们用上道颜色划分题目“数组分三块”的思想，实现快排

过程分析:

nums[i] < key ：swap(nums[++left], nums[i++])

nums[i] == key ：++i

nums[i] == 2 :  swap(nums[--right], nums[i])

一次划分完之后，数组就如下所示: 然后递归黄色区间和紫色区间即可

当数组中全都是重复元素时，一次划分之后数组黄色区间和紫色区间就不存在了，递归结束

key的选取:

随机选取key时，时间复杂度渐进到o(nlogn)

3.算法代码

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        srand(time(nullptr)); //种下一颗种子
        qsort(nums, 0, nums.size()-1);
        return nums;
    }

    void qsort(vector<int>& nums, int l, int r)
    {
        //递归结束条件
        if(l >= r) return;

        //数组分三块
        int key = getRandom(nums, l, r);
        int i = l, left = l - 1, right = r + 1;
        while(i < right)
        {
            if(nums[i] < key) swap(nums[++left], nums[i++]);
            else if(nums[i] == key) i++;
            else swap(nums[--right], nums[i]);
        }
        //[l, left], [left+1, right-1] [right, r];
        qsort(nums, l, left);
        qsort(nums, right, r);
    }

    int getRandom(vector<int>& nums, int left, int right)
    {
        int r = rand();
        return nums[r % (right - left + 1) + left];
    }
};

三、数组中的第K个最大元素

215. 数组中的第K个最大元素 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/kth-largest-element-in-an-array/1.题目解析

求数组中第K大元素

2.算法分析

解法一: Top-k问题，采用堆/优先级队列解决

解法二: 快速选择算法(基于快排)

如果我们对数组分三块之后，找第K大的元素就会快很多

1. c >= k, 那么第k大于元素落在紫色区间，递归该区间即可

2. b + c >= k(1已经不满足了), 那么第k大元素落在蓝色区间，而蓝色区间值都相等，直接返回 k 即可

3. 第k大元素元素落在黄色区间，递归该区间即可， 注意此时在黄色区间找的是第k-a-b大的元素

3.算法代码

解法一: 优先级队列

class Solution 
{
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        priority_queue<int> q(nums.begin(), nums.end());
        while(--k)
            q.pop();
        return q.top();
    }
};

解法二: 快速选择算法

class Solution 
{
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        srand(time(nullptr));
        return qsort(nums, 0, nums.size()-1, k);
    }

    int qsort(vector<int>& nums, int l, int r, int k)
    {
        if(l == r) return nums[l];

        //1.随机选择基准元素
        int key = getRandom(nums, l, r);

        //2.数组分三块
        int i = l, left = l-1, right = r+1;
        while(i < right)
        {
            if(nums[i] < key) swap(nums[++left], nums[i++]);
            else if(nums[i] == key) ++i;
            else swap(nums[--right], nums[i]);
        }

        //3.找第k大元素
        int c = r - right + 1, b = right - left - 1;
        if(c >= k) return qsort(nums, right, r, k);
        else if(b + c >= k) return key;
        else return qsort(nums, l, left, k - b -c);
    }

    int getRandom(vector<int>& nums, int left, int right)
    {
        int r = rand();
        return nums[r % (right - left + 1) + left];
    }
};

四、库存管理

LCR 159. 库存管理 III - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/zui-xiao-de-kge-shu-lcof/1.题目解析

求数组中最小的k个数

2.算法分析

法一:排序

法二:优先级队列

法三:快速选择算法

如果我们用快速选择算法对数组分三块之后，求数组中最小的k个数就会快很多

1. a > k, 则最小的k个数都落在黄色区间，递归黄色区间即可

2. a+b>=k, 说明已经找到了前k小的元素，返回即可

3. 递归紫色区间， 注意此时在紫色区间找的是前k-a-b小的元素

3.算法代码

法一:排序

class Solution {
public:
    vector<int> inventoryManagement(vector<int>& stock, int cnt) 
    {
        vector<int> ret;
        sort(stock.begin(), stock.end());
        for(int i = 0; i < cnt; i++)
            ret.push_back(stock[i]);
        return ret;
    }
};

法二:优先级队列

class Solution {
public:
    vector<int> inventoryManagement(vector<int>& stock, int cnt) 
    {
        vector<int> ret;
        priority_queue<int, vector<int>, greater<int>> q; //小堆
        for(auto& e : stock)
            q.push(e);
        while(cnt--)
        {
            ret.push_back(q.top());
            q.pop();   
        }
        return ret;
    }
};

法三:快速选择算法

class Solution 
{
public:
    vector<int> inventoryManagement(vector<int>& nums, int k) 
    {
        srand(time(nullptr));
        qsort(nums, 0, nums.size()-1, k);
        return {nums.begin(), nums.begin() + k};
    }

    void qsort(vector<int>& nums, int l, int r, int k)
    {
        if(l >= r) return;

        //1.选择随机数做key
        int key = getRandom(nums, l, r);

        //2.数组分三块
        int left = l-1, right = r+1, i = l;
        while(i < right)
        {
            if(nums[i] < key) swap(nums[++left], nums[i++]);
            else if(nums[i] == key) i++;
            else swap(nums[--right], nums[i]);
        }

        //3.找最小的k个元素
        int a = left - l + 1, b = right - left - 1;
        if(a > k) return qsort(nums, l, left, k);
        else if(a + b >= k) return;
        else return qsort(nums, right, r, k-a-b);
    }

    int getRandom(vector<int>& nums, int l, int r)
    {
        return nums[rand() % (r-l+1) + l];
    }
};

分治-归并

一、排序数组

912. 排序数组 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/sort-an-array/description/1.题目解析

排序数组，升序

2.算法分析

在"分治-快排"中，我们使用快速排序解决了数组升序，这次我们使用归并排序解决问题，选择排序和归并排序都是"分治"思想，可以把"快排"理解成二叉树前序遍历，把"归并"理解成二叉树后序遍历, 详细分析见博客: 排序素来美如玉，层进理解获芳心-CSDN博客

3.算法代码

class Solution {
    vector<int> tmp;
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        tmp.resize(nums.size());
        merge_sort(nums, 0, nums.size()-1);
        return nums;
    }

    void merge_sort(vector<int>& nums, int left, int right)
    {
        //递归结束条件
        if(left >= right) return;

        //1.选择中间节点划分区间
        int mid = (right + left) >> 1;
        //[left, mid], [mid+1, right]

        //2.递归左右区间
        merge_sort(nums, left, mid);
        merge_sort(nums, mid+1, right);

        //3.合并两个有序数组
        //vector<int> tmp(right - left + 1); 在递归过程中，每次都要创建，最好写成全局变量
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right)
            tmp[i++] = nums[cur1] <= nums[cur2] ? nums[cur1++] : nums[cur2++];
        //处理没有遍历完的数组
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];
        //还原
        for(int i = left; i <= right; i++)
            nums[i] = tmp[i - left];
    }
};

二、交易逆序对的总数

LCR 170. 交易逆序对的总数 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/description/1.题目解析

逆序对是指数对中第一个数>第二个数,  题目要求返回逆序对的个数

2.算法分析
显然可以直接暴力枚举，但是时间复杂度太高，直接超时， 下面是采用归并排序思想解决问题

2.1.将数组划分成两部分，左半部分找一下逆序对，右半部分找一下逆序对，一左一右找一下逆序对，因为本质还是暴力枚举，所以结果一定是正确的

2.2 将数组划分成两部分，左半部分找一下逆序对，然后左半部分排序，右半部分找一下逆序对，然后右半部分排序，一左一右找一下逆序对，结果也是正确的，因为排序并不影响逆序对情况~

由于在左半部分找逆序、右半部分找逆序对以及整个一左一右找逆序对，都属于同一类问题，因此可以用递归求解，而左半部分和右半部分找到逆序对之后都要排序，所以我们在一左一右找完逆序对之后也加一个排序的操作, 分析到这显然就可以用归并排序来求解这道问题了~

下面就是分析左右部分递归完之后，如何一左一右找逆序对的问题了~

策略一: 找出该数之前，有多少数比我大(也就是看左区间内有多少数比nums[cur2]大)

一左一右找逆序对就可以完美的和归并排序中合并两个有序数组完美契合~

ps: 由合并两个有序数组的逻辑知，哪个指针指向的元素小，就让哪个指针++， 因此[left, cur1-1]区间的所有值都比nums[cur2]小~

①nums[cur1] <= nums[cur2], 说明，对于cur2位置的元素而言，左区间还没有值比nums[cur2]大，没有出现逆序对, 因此继续让cur1++即可

②nums[cur1] > nums[cur2],  而左区间是升序，所以cur1位置之后的所有元素都 > nums[cur2], 此时逆序对的数量 ret += (mid-cur1+1), 然后cur2++来到下一个位置即可

ps:上述合并两个有序数组过程依旧是借助辅助数组来完成的~

注意:该策略数组必须排升序，不能是降序

如果是降序，根据归并排序合并两个有序数组，哪个指针指向元素大，哪个指针++， 因此[left, cur1-1]区间的所有值都比nums[cur2]大

此时如果nums[cur1] > nums[cur2], 说明cur1连同cur1之前的左区间元素都比nums[cur2]大， 此时如果统计了逆序对数量，cur1++之后来到下一个位置，此时nums[cur1]依旧可能 > nums[cur2], 还要统计逆序对数量，就会重复计算!!

因此策略一数组只能排升序!

策略二: 找出该数之后，有多少数比我小(也就是看右区间内有多少数比nums[cur1]小)

ps: 由合并两个有序数组的逻辑知 [mid+1, cur2]区间的所有值都比nums[cur1] 大

①nums[cur1] <= nums[cur2], 说明，对于cur1位置的元素而言，右区间还没有值比nums[cur2]小，没有出现逆序对, 因此继续让cur2++即可

②nums[cur1] > nums[cur2],  而右区间是降序，所以cur2位置之后的所有元素都 < nums[cur1], 此时逆序对的数量 ret += (right-cur2+1), 然后cur1++来到下一个位置即可
ps:上述合并两个有序数组过程依旧是借助辅助数组来完成的~

注意:该策略数组必须排降序，不能是升序

如果是升序，根据归并排序合并两个有序数组，哪个指针指向元素小，哪个指针++， 因此[mid+1, cur2]区间的所有值都比nums[cur1]小

如果nums[cur1] > nums[cur2], 说明cur2连同cur2之前的右区间所有元素都比cur1小， 此时如果统计了逆序对数量，cur2++之后来到下一个位置，此时nums[cur1]依旧可能 > nums[cur2], 还要统计逆序对数量，就会重复计算!!

3.算法代码

策略一：

class Solution {
    int tmp[50010];
public:
    int reversePairs(vector<int>& nums) 
    {
        return merge_sort(nums, 0, nums.size()-1);
    }

    int merge_sort(vector<int>& nums, int left, int right)
    {
        if(left >= right) return 0;
        int ret = 0; //最终逆序对的数量
        //1.找中间点，将数组分成两部分
        int mid = (left + right) >> 1;

        //2.左边的逆序对个数 + 排序 + 右边的个数 + 排序
        ret += merge_sort(nums, left, mid);
        ret += merge_sort(nums, mid+1, right);

        //3.一左一右的逆序对个数 + 排序
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right)
        {
            if(nums[cur1] <= nums[cur2])
            {
                tmp[i++] = nums[cur1++];
            }
            else
            {
                ret += mid - cur1 + 1;
                tmp[i++] = nums[cur2++];
            }
        }

        //4.序序的剩余工作
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];
        //还原
        for(int i = left; i <= right; i++)
            nums[i] = tmp[i-left];
        
        return ret;
    }
};

策略二:

class Solution {
    int tmp[50010];
public:
    int reversePairs(vector<int>& nums) 
    {
        return merge_sort(nums, 0, nums.size()-1);
    }

    int merge_sort(vector<int>& nums, int left, int right)
    {
        if(left >= right) return 0;
        int ret = 0; //最终逆序对的数量
        //1.找中间点，将数组分成两部分
        int mid = (left + right) >> 1;

        //2.左边的逆序对个数 + 排序 + 右边的个数 + 排序
        ret += merge_sort(nums, left, mid);
        ret += merge_sort(nums, mid+1, right);

        //3.一左一右的逆序对个数 + 排序
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right)
        {
            if(nums[cur1] <= nums[cur2])
            {
                tmp[i++] = nums[cur2++];
            }
            else
            {
                ret += right - cur2 + 1;
                tmp[i++] = nums[cur1++];
            }
        }

        //4.排序的剩余工作
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];
        //还原
        for(int i = left; i <= right; i++)
            nums[i] = tmp[i-left];
        
        return ret;
    }
};

三、计算右侧小于当前元素的个数

315. 计算右侧小于当前元素的个数 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/count-of-smaller-numbers-after-self/1.题目解析

本题和题目二求逆序对数量非常相似，不过本题是要返回一个数组，数组的每个元素是原数组元素右侧小于当前元素的个数

2.算法分析

类似题目二，采用归并排序的方法求解

题目二已经详细分析了两种策略，很明显，本题是用策略二，因为本题求的是当前元素以后，有多少个元素比我小, 所以数组应该排降序~

①nums[cur1] <= nums[cur2]：  cur2++

②nums[cur1] > nums[cur2],  由于要返回数组，此时让nums[cu1]元素对应的原始数组下标的位置 的 ret += (right-cur2+1), cur1++

由于处理一左一右的情况是在左右区间都分别排序之后，下标就乱了，所以本题的关键就是要求nums中当前元素的原始下标是多少?

开一个和原始数组大小一样的index数组，将原始数组元素和下标绑定即可~

所以在合并有序数组的时候，nums和index数组都要进行合并，包括后续的还原等工作，都是如此

因此写代码时要有两个辅助数组来解决问题~

3.算法代码

class Solution 
{
    vector<int> ret; //写成全局，不用传成递归参数
    vector<int> index; //记录nums数组当前元素的原始下标
    int tmp_nums[100001]; //辅助数组，用于nums数组中左右两个有序数组的合并
    int tmp_index[100001]; //辅助数组，用于index数组中左右两个有序数组的合并
public:
    vector<int> countSmaller(vector<int>& nums) 
    {
        int n = nums.size();
        ret.resize(n);
        index.resize(n);

        //初始化index数组
        for(int i = 0; i < n; i++)
            index[i] = i;

        merge_sort(nums, 0, nums.size()-1);
        return ret;
    }

    void merge_sort(vector<int>& nums, int left, int right)
    {
        //递归结束
        if(left >= right) return;
        //1.求中间元素下标
        int mid = (left + right) >> 1;
        //[left, mid] [mid+1, right]
        //2.递归左右区间
        merge_sort(nums, left, mid);
        merge_sort(nums, mid+1, right);
        //3.处理一左一右
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right)
        {
            if(nums[cur1] <= nums[cur2])
            {
                tmp_nums[i] = nums[cur2];
                tmp_index[i++] = index[cur2++];
            }
            else
            {
                ret[index[cur1]] += right-cur2+1;
                tmp_nums[i] = nums[cur1]; 
                tmp_index[i++] = index[cur1++];
            }
        }
        //4.排序的剩余工作
        while(cur1 <= mid) 
        {
            tmp_nums[i] = nums[cur1]; 
            tmp_index[i++] = index[cur1++];
        }
        while(cur2 <= right) 
        {
            tmp_nums[i] = nums[cur2];
            tmp_index[i++] = index[cur2++];
        }
        //还原
        for(int i = left; i <= right; i++)
        {
            nums[i] = tmp_nums[i - left];
            index[i] = tmp_index[i - left];
        }
    }
};

四、翻转对

493. 翻转对 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/reverse-pairs/1.题目解析

翻转对指的是数对中第一个数大于第二个数的两倍,  返回数组中所有翻转对的个数

2.算法分析

首先这道题也是使用分治的思想，整体流程也是将数组划分为两部分，左区间求逆序对数量+排序，右区间求逆序对数量+排序, 然后一左一右求逆序对数量+排序,  但是找翻转对的方法和归并排序中合并两个有序数组并没有完美契合，因为合并两个有序数组判断的是nums[cur1]和nums[cur2]的大小关系，而翻转对要判断的是nums[cur1]与2*nums[cur2]的关系，因此我们可以在合并两个有序数组之前先把翻转对的数量求出来~

策略一:计算当前元素后面，有多少元素的两倍比我小

①nums[cur1] <= 2*nums[cur2], cur2++ 

②nums[cur1]  > 2*nums[cur2], 而数组又是降序，因此cur2位置之后的所有元素的2倍都小于nums[cur1],  ret += right-cur2+1, 然后cur1++

注意情况②cur1++之后，cur2不用回退，因为cur2位置之前的元素的2倍都是大于nums[cur1]的，而数组是降序，cur1++之后，nums[cur1]值更小了，因此cur2回退之后又会一路++到如图位置， 时间复杂度太高了~

策略二:计算当前元素前面，有多少元素的一半比我大

①nums[cur1]  / 2.0  <=  nums[cur2], cur1++ 

②nums[cur1] / 2.0 > nums[cur2], 而数组又是升序，因此cur1位置之后的所有元素的一半都大于nums[cur2],  ret += mid-cur1+1, 然后cur2++

注意情况②cur2++之后，cur1不用回退，因为cur1位置之前的元素的一半都是 <= nums[cur2]的，而数组是升序，cur2++之后，nums[cur2]值更大了，因此cur1回退之后又会一路++到如图位置， 时间复杂度太高了~

3.算法代码

策略一:

class Solution
{
    int tmp[50001];
public:
    int reversePairs(vector<int>& nums) 
    {
        return merge_sort(nums, 0, nums.size()-1);
    }
    int merge_sort(vector<int>& nums, int left, int right)
    {
        int ret = 0;

        //递归结束条件
        if(left >= right) return 0;
        //1.根据中间元素划分区间
        int mid = (left + right) >> 1;
        //2.计算左右区间的翻转对数量
        ret += merge_sort(nums, left, mid);
        ret += merge_sort(nums, mid+1, right);
        //3.计算一左一右翻转对数量
        int cur1 = left, cur2 = mid + 1;
        while(cur1 <= mid)
        {
            while(cur2 <= right && nums[cur1] / 2.0 <= nums[cur2]) //写成 2*nums[cur2] 会超范围
                cur2++;
            if(cur2 > right) break;
            ret += right - cur2 + 1;
            cur1++;
        }
        //4.合并两个有序数组
        cur1 = left, cur2 = mid + 1;
        int i = 0;
        while(cur1 <= mid && cur2 <= right)
            tmp[i++] = nums[cur1] >= nums[cur2] ? nums[cur1++] : nums[cur2++];
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];

        //还原
        for(int i = left; i <= right; i++)
            nums[i] = tmp[i - left];

        return ret;
    }
};

策略二:

class Solution
{
    int tmp[50001];
public:
    int reversePairs(vector<int>& nums) 
    {
        return merge_sort(nums, 0, nums.size()-1);
    }
    int merge_sort(vector<int>& nums, int left, int right)
    {
        int ret = 0;

        //递归结束条件
        if(left >= right) return 0;
        //1.根据中间元素划分区间
        int mid = (left + right) >> 1;
        //2.计算左右区间的翻转对数量
        ret += merge_sort(nums, left, mid);
        ret += merge_sort(nums, mid+1, right);
        //3.计算一左一右翻转对数量
        int cur1 = left, cur2 = mid + 1;
        while(cur2 <= right)
        {
            while(cur1 <= mid && nums[cur1] / 2.0 <= nums[cur2]) //写成 2*nums[cur2] 会超范围
                cur1++;
            if(cur1 > mid) break;
            ret += mid - cur1 + 1;
            cur2++;
        }
        //4.合并两个有序数组
        cur1 = left, cur2 = mid + 1;
        int i = 0;
        while(cur1 <= mid && cur2 <= right)
            tmp[i++] = nums[cur1] <= nums[cur2] ? nums[cur1++] : nums[cur2++];
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];

        //还原
        for(int i = left; i <= right; i++)
            nums[i] = tmp[i - left];

        return ret;
    }
};

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

2024年云仓酒庄新动态合肥北京双城开课，持续培训助力酒业发展

2024年云仓酒庄新动态合肥北京双城开课，持续培训助力酒业发展

云仓酒庄合肥北京双城开课&#xff0c;持续培训助力酒业发展 随着国内酒类市场的不断繁荣与消费需求的日益增长&#xff0c;云仓酒庄作为行业内的稳扎稳打之一的企业&#xff0c;始终致力于提升服务质量和品牌影响力。近日&#xff0c;云仓酒庄在合肥与北京两地同时开设培训课…
阅读更多...
qt学习篇---C++基础学习

qt学习篇---C++基础学习

本学习笔记学习下面视频总结&#xff0c;感兴趣可以去学习。讲的很详细 【北京迅为】嵌入式学习之QT学习篇_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1tp4y1i7EJ/?spm_id_from333.337.search-card.all.click&vd_source8827cc0da16223b9f2ad8ae7111de9e2 目录 C…
阅读更多...
JavaScript数组方法练习

JavaScript数组方法练习

第一个练习 ● 计算所有账户的存款总额 const bankDepositSum accounts //定义一个变量.flatMap(acc > acc.movements) //使用flatmap将所有的存款提取&#xff0c;然后组成一个新的数组.filter(mov > mov > 0) //使用filter方法提取所有的正值.reduce((sum, c…
阅读更多...
【前端】VUE项目创建

【前端】VUE项目创建

在所需文件夹中打开cmd命令行窗口&#xff0c;输入vue ui 进入web可视化界面选择创建新项目 根据需求依次完成下列选择&#xff0c;下列是参考配置&#xff0c;完成后点击创建项目即可 最终显示完成
阅读更多...
upload-labs后续（14-）

upload-labs后续（14-）

图片马 在图片中加入木马&#xff0c;然后上传让浏览器解析&#xff0c;达到上传木马的目的 制作图片马&#xff1a;可以在notepad或者winhex中打开文件&#xff0c;在文件头中加入图片的文件头&#xff0c;再在文件末尾加入木马即可。 图片文件头如下&#xff1a; 1.Png图片…
阅读更多...
B站广告推广开户最低需要多少钱？

B站广告推广开户最低需要多少钱？

在竞争激烈的互联网营销环境中&#xff0c;哔哩哔哩&#xff08;B站&#xff09;作为深受年轻人喜爱的视频分享平台&#xff0c;其广告价值不容小觑。对于希望在B站上进行广告推广的企业或个人而言&#xff0c;了解开户流程及成本&#xff0c;选择专业的服务团队至关重要。介绍…
阅读更多...
AI图书推荐：ChatGPT写论文的流程与策略

AI图书推荐：ChatGPT写论文的流程与策略

论文一直是任何学术学位的顶峰。它展示了学生在研究领域的兴趣和专业知识。撰写论文也是一个学习经验&#xff0c;为学术工作以及专业研究角色做好准备。但是&#xff0c;论文工作总是艰苦的&#xff0c;通常是充满乐趣和创造性的&#xff0c;但有时也是乏味和无聊的。生成式人…
阅读更多...
kerberos-hive-dbeaver问题总结

kerberos-hive-dbeaver问题总结

一、kerberos安装windows客户端 1、官方下载地址 http://web.mit.edu/kerberos/dist/ 2、环境变量配置 下载msi安装包&#xff0c;无需重启计算机&#xff0c;调整环境变量在jdk的前面&#xff0c;尽量靠前&#xff0c;因为jdk也带了kinit、klist等命令 C:\Program Files\…
阅读更多...
Kotlin泛型之 循环引用泛型（A的泛型是B的子类，B的泛型是A的子类）

Kotlin泛型之 循环引用泛型（A的泛型是B的子类，B的泛型是A的子类）

IDE(编辑器)报错 循环引用泛型是我起的名字&#xff0c;不知道官方的名字是什么。这个问题是我在定义Android 的MVP时提出来的。具体是什么样的呢&#xff1f;我们看一下我的基础的MVP定义&#xff1a; interface IPresenter<V> { fun getView(): V }interface IVie…
阅读更多...
41. UE5 RPG 设置火球术的碰撞类型

41. UE5 RPG 设置火球术的碰撞类型

在上一篇中&#xff0c;我们设置了火球术从发射到击中敌人的整个周期使用的音效和特效&#xff0c;现在看上去它像一个真正的火球术了。在这一篇文章里面&#xff0c;我们主要解决一下火球术碰撞的问题&#xff0c;现在已知的问题是&#xff0c;有些不需要和火球产生碰撞的物体…
阅读更多...
代码随想录-二叉树（节点）

代码随想录-二叉树（节点）

目录 104. 二叉树的最大深度 题目描述&#xff1a; 输入输出描述&#xff1a; 思路和想法&#xff1a; 111. 二叉树的最小深度 题目描述&#xff1a; 输入输出描述&#xff1a; 思路和想法&#xff1a; 222. 完全二叉树的节点个数 题目描述&#xff1a; ​输入输出描…
阅读更多...
商汤研究院招大模型实习生

商汤研究院招大模型实习生

商汤研究院招大模型实习生&#xff0c;base上海、北京&#xff0c;400/day。福利&#xff1a;每天50租房补贴&#xff0c;20的餐补。晚上8点之后回去有额外的25元晚餐餐补&#xff0c;10点之后回去可以免费用滴滴。 组内的大模型工作大概分两个方向&#xff1a; 1.3B、3B等小…
阅读更多...
特别的时钟特别的倒计时

特别的时钟特别的倒计时

念念不忘的歌曲&#xff1a;Thats Why You Go Away <!DOCTYPE html> <html lang"zh-CN"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title&…
阅读更多...
IDEA新版本创建Spring项目只能勾选17和21却无法使用Java8的完美解决方案

IDEA新版本创建Spring项目只能勾选17和21却无法使用Java8的完美解决方案

想创建一个springboot的项目&#xff0c;使用Spring Initializr创建项目时&#xff0c;发现版本只有17&#xff5e;21&#xff0c;无法选择Java8。 我们知道IDEA页面创建Spring项目&#xff0c;其实是访问spring initializr去创建项目。我们可以通过阿里云国服间接创建Spring项…
阅读更多...
工业异常检测

工业异常检测

工业异常检测在业界和学界都一直是热门&#xff0c;近期其更是迎来了全新突破&#xff1a;与大模型相结合&#xff01;让异常检测变得更快更准更简单&#xff01; 比如模型AnomalyGPT&#xff0c;它克服了以往的局限&#xff0c;能够让大模型充分理解工业场景图像&#xff0c;判…
阅读更多...
Redis哈希槽和一致性哈希

Redis哈希槽和一致性哈希

前言 单点的Redis有一定的局限&#xff1a; 单点发生故障&#xff0c;数据丢失&#xff0c;影响整体服务应用自身资源有限&#xff0c;无法承载更多资源分配并发访问&#xff0c;给服务器主机带来压力&#xff0c;性能瓶颈 我们想提升系统的容量、性能和可靠性&#xff0c;就…
阅读更多...
paddleocr C++生成dll

paddleocr C++生成dll

目录 编译完成后修改内容: 新建ppocr.h头文件 注释掉main.cpp内全部内容&#xff0c;将下面内容替换进去。ppocr.h需要再环境配置中包含进去头文件 然后更改配置信息&#xff0c;将exe换成dll 随后右击重新编译会在根目录生成dll,lib文件。 注意这些dll一个也不能少。生成…
阅读更多...
伪装目标检测论文阅读 SAM大模型之参数微调：Conv LoRA

伪装目标检测论文阅读 SAM大模型之参数微调：Conv LoRA

paper&#xff1a;link code&#xff1a;还没公开 摘要 任意分割模型(SAM)是图像分割的基本框架。虽然它在典型场景中表现出显著的零镜头泛化&#xff0c;但当应用于医学图像和遥感等专门领域时&#xff0c;其优势就会减弱。针对这一局限性&#xff0c;本文提出了一种简单有效…
阅读更多...
Java进阶-JavaStreamAPI的使用

Java进阶-JavaStreamAPI的使用

本文全面介绍了 Java Stream API 的概念、功能以及如何在 Java 中有效地使用它进行集合和数据流的处理。通过详细解释和示例&#xff0c;文章展示了 Java Stream API 在简化代码、提高效率以及支持函数式编程方面的优势。文中还比较了 Java Stream API 与其他集合处理库的异同&…
阅读更多...
Django之搭配内网穿透

Django之搭配内网穿透

一&#xff0c;安装coplar 二&#xff0c;开启8087的内网穿透 三&#xff0c;setting.py中加入如下配置&#xff1a; ALLOWED_HOSTS [*]CSRF_TRUSTED_ORIGINS ["https://localhost:8087", "http://localhost:8087"]四&#xff0c;启动项目 五&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023