贪心算法入门(一)

1.什么是贪心算法?

        贪心算法是一种解决问题的策略,它将复杂的问题分解为若干个步骤,并在每一步都选择当前最优的解决方案,最终希望能得到全局最优解。这种策略的核心在于“最优”二字,意味着我们追求的是以最少的时间和精力,快速获得正确的结果。

        然而,“希望得到全局最优解”就表示贪心算法并不意味着一定能得到全局最优解。实际上,并不是所有问题都可以通过贪心策略解决。为了确保贪心策略的有效性,需要对其进行严格的证明。而且,不同的问题往往需要采用不同的贪心策略。

        如果你觉得这一点仍然比较抽象,接下来我将通过五道具体的例题来详细说明贪心算法的应用及其背后的思路。

2.柠檬水找零

860. 柠檬水找零 - 力扣(LeetCode)

通过示例和问题描述,理解这个问题并不难,所以我就不过多阐述了。就是看能不能给bills数组里面的每个顾客正确的找零,并且一开始我们手上是没有零钱的,也就意味着如果bills[0] > 5, 那么我们是没有办法给顾客找零的,因为此时我们还没有任何零钱。以此类推,当检索完整个数组都能正确找零时返回true,否则返回false。

在理清问题后,不要急于去想出一个贪心策略,也不要急于去想用代码如何实现。而是首先在你脑子里面去想示例里面的答案是如何一步一步得到的。

 示例1中,第1位顾客用5美元买柠檬水,不用找零,与此同时我们手上多了一张5元的零钱。以此类推,直到第4位顾客付了10美元,我们需要找零5美元,此时我们的零钱库中有3张5美元,可以正确找零,此时零钱库变为2张5美元,1张10美元。最后一位顾客,我们只需找1张10美元和1张5美元,故可以实现正确找零,返回true。

再把以上思路,变现为代码即可。但其实还有一个细节问题需要我们考虑,就是如果顾客支付20元,而此时我们的零钱库中有3张5美元和1张10美元,那么我们应该选择3张5美元还是1张10美元1张5美元进行找补呢?这时可能会想到用递归的方式将两种方式递归下去,只要有一种的结果为true那么就为true。但同时递归这种方式时间复杂度就会大大提升。此时能不能有一种贪心策略去简化呢?

3张5美元和1张10美元1张5美元,应该更优先选择1张10美元1张5美元进行找补。这就是我们贪心的地方,因为5美元的用处比10美元更大,当顾客支付10美元时,5美元可以找补,同时5美元也可以为20找补。所以我们应该留着用处更大的5美元,以备不时之需。

那么这种策略对不对呢,这个贪心策略得到的结果是不是正确的,需要证明。我们可以反推假设,假设在最优解中,我们在某一次找补20美元的选择中,并没有选择1张10美元和1张5美元,而是选择了3张5美元。而我们的贪心策略是要选择1张10美元和1张5美元的,我们把贪心的选择往假设的最优解中进行替换,看是否会影响后续结果。

代码实现

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int five = 0, ten = 0; // five表示零钱库中5美元的张数,ten表示10美元的张数
        for(int i = 0; i < bills.length; i++){ 
            if(bills[i] == 5) five++; // 更新零钱库
            else if(bills[i] == 10){
                if(five == 0) return false; // 如果零钱库没有5美元返回false
                five--;ten++; // 更新零钱库
            }
            else{
                if(ten > 0 && five > 0) {ten--;five--;} // 优先选择用10美元和5美元找补
                else if(five >= 3) five -= 3; // 次选3张5美元(在没有10美元的情况下)
                else return false; // 上述条件都不满足则没有合适的零钱找补返回false
            }
        }
        return true;
    }
}

3. 将数组和减半的最少操作次数

2208. 将数组和减半的最少操作次数 - 力扣(LeetCode)

这道题的贪心策略并不难想,要让操作次数最少,只需每次都挑出数组最大的数进行减半,但是需要注意的是,减半后的数也需要放回原数组,然后挑出最大值。所以不能直接将数组用sort方法进行排序,因为还需要将减半后的数重新放回数组进行比较。采取使用大根堆的数据结构即可。

代码实现

class Solution {
    public int halveArray(int[] nums) {
        PriorityQueue<Double> q = new PriorityQueue<>((a, b) -> Double.compare(b, a));
        int ret = 0;
        double sum = 0;
        for(int x : nums){sum += x;q.add((double) x);} // 原数组总和
        sum /= 2.0; // 计算总和的一半
        while(sum > 0){
            double t = q.poll() / 2.0; // 拿出堆中最大的数
            sum -= t;
            ret++;
            q.offer(t);// 减半后的数重新放回大根堆
        }
        return ret;
    }
}

4.最大数

179. 最大数 - 力扣(LeetCode)

以示例1为例,10和2我们很容易看出来,应该让2在高位,10放在2后面。所以实现的逻辑就是,把两个数从高位到低位的数字挨个比较,直至数字不同,并把数字大的放在前面。比如10和2的比较逻辑就是,10的第一位数字1和2比较,2比1大所以放前面。再比如23和22, 23的第一位是2,22的第一位也是2,所以继续向后比较就3和2比较,所以23和22组成的最大值应该是2322。

但还存在一种情况就是,2和20,这种情况应该把谁放在前面呢,肉眼观察最大值应该是220,所以应该把2放前面20放后面。但是这个结论我们应该用逻辑推敲出来而不是凭空想。难道遇到这种情况就是把位数少的放前面吗?那2和24就显然不是这种情况,因为224比242要小。但是从这两个例子就可以看出端倪了,如果多出的数字比首位大那么就是位数多的排前面,否则排后面。2和20中0比2小,所以20应该排在后面,而2和24中4比2大,所以24应该排前面。

所以我们只要按照这种方法对数组进行降序排序,再依次遍历数组就可以得到最终结果值。其实还有一种更简单的比较方法,就是将数a和数b都转换为字符串,然后比较 a + b(a在前,b在后)大还是(b + a)大即可。

代码实现

class Solution {
    public String largestNumber(int[] nums) {
        String[] s = new String[nums.length];
        for(int i = 0; i < nums.length; i++) s[i] = "" + nums[i]; // 将数转换为字符串存入字符数组
        Arrays.sort(s, (a, b) -> (b + a).compareTo(a + b)); // 按照比较方法对字符数组进行降序排序
        if(Objects.equals(s[0],"0")) return "0"; // 判断特殊情况,如果排序后的最大值是0就返回0
        StringBuilder ret = new StringBuilder();
        for(String t : s) ret.append(t); // 依次添加
        return ret.toString();
    }
} 

5.摆动序列

376. 摆动序列 - 力扣(LeetCode)

摆动序列其实就是一种波浪型曲线,要你找的这个子序列必须是先升再降再升再...,或者先降再升再降...。而且子序列就表示中间可以不用是连续的,也就表明你可以在数组里面跳着挑满足摆动的数。最终找出最长的子序列即可。

我先说一下我一开始看到这道题的思路,就是用动态规划。但其实这道题用贪心的思路是更简单的,但是动态规划和贪心的时间复杂度是一样的。我在力扣上跑的结果所花的时间也是差不多的。只是贪心的逻辑会更简单,但是贪心的策略是比较扩散性思维才能想到的,但是也不难。这里想讲一下动态规划的思路是因为是比较容易想和常规的。如果想直接看贪心策略的可以直接跳到贪心的思路。

动态规划思路:

首先明确状态表示,最开始想的是dp[i]表示以i位置为结尾的摆动最长子序列长度,但是很快被否定了,因为这样我没有办法写状态转移方程,因为我不知道以i位置结尾的是上升趋势还是下降趋势,就没有办法知道后续那个数可以加在这个状态之上。所以用两个数组表示不同的状态。

 int[] f = new int[n]; // 以i结尾并且为上升趋势的摆动序列最长长度
 int[] g = new int[n]; // 以i结尾并且为下降趋势的摆动序列最长长度

 当nums[ j ] < nums[ i ] (j 表示在 i 之前的所有索引值),为上升趋势,所以应该连上为下降趋势的序列组成新的摆动序列,即更新 f[ i ] = g[ i ] + 1,  当nums[ j ] > nums[ i ] 时, 更新g[ i ] = f[ i ] + 1。需要注意的是在更新i位置的值时,需要把i之前的所有的f[ j ] 和 g[ j ]都遍历比较一遍,看接在哪个位置后才能组成最长的摆动子序列。还有就是初始值问题,每个数自己也能单独组成摆渡序列,所以f [ i ] 和 g [ i ] 的初始值都应该为1。

动规代码实现:

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        int[] f = new int[n]; // 以i结尾并且为上升趋势
        int[] g = new int[n]; // 以i结尾并且为下降趋势
        for(int i = 0; i < n; i++) f[i] = g[i] = 1;
        int ret = 1;
        for(int i = 1; i < n; i++){
            for(int j = 0; j < i; j++){
                if(nums[j] > nums[i]) g[i] = Math.max(g[i], f[j] + 1);
                if(nums[j] < nums[i]) f[i] = Math.max(f[i], g[j] + 1);
            }
            ret = Math.max(ret, Math.max(f[i], g[i]));
        }
        return  ret;
    }
}

以上实现思路时间复杂度为n², 因为多了一个找出最合适j位置的循环。所以我的优化思路就是想把这个寻找j位置的循环省掉。如果我的f 和 g函数表示在0 - i区间内最长摆动子序列的值,我就不用去找j位置了,直接用这个值往上加即可。但是这样的话我的判断条件又会缺少值,因为不知道最长子序列的最后一位数是什么,就没有办法判断哪些数可以接在后面,所以又新开一个二维数组hash,hash[i][0]表示在0-i区间内最长摆动序列且结尾为下降趋势的最后一位数的值,hash[i][1]表示在0-i区间内最长摆动序列且结尾为上升趋势的最后一位数的值。

所以条件判断变成了,nums[ i ] 和 hash [ i - 1] [ 0 ] 、 hash [ i - 1] [ 1 ] 进行比较,如果nums[ i ]  >  hash [ i - 1] [ 0 ], 表示当前位置的值大于在0 - i - 1区间内结尾为下降趋势的最长摆动序列的最后一位数,满足条件则更新f[ i ] 的值,并且hash [ i ] [ 1 ] 也要更新为当前数。

f[i] = g[i - 1] + 1; hash[i][1] = nums[i];

 如果不满足,f[ i ] 的值应该延续 f[ i - 1] 的值,并且hash [ i ] [ 1 ] 也应该延续hash [ i - 1] [ 1 ] 的值。

g[i]同理。

优化后的代码:

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        int[] f = new int[n]; // 在0-i区间内 结尾为上升趋势
        int[] g = new int[n]; // 在0-i区间内 结尾并且为下降趋势
        for(int i = 0; i < n; i++) f[i] = g[i] = 1;
        int[][] hash = new int[n][2];
        hash[0][0] = hash[0][1] = nums[0];
        for(int i = 1; i < n; i++){
           if(nums[i] > hash[i - 1][0]) { f[i] = g[i - 1] + 1; hash[i][1] = nums[i]; }
           else { f[i] = f[i - 1];  hash[i][1] = hash[i - 1][1];}
           if(nums[i] < hash[i - 1][1]) { g[i] = f[i - 1] + 1; hash[i][0] = nums[i]; }
           else { g[i] = g[i - 1];  hash[i][0] = hash[i - 1][0];}
        }
        return  Math.max(f[n -1], g[n - 1]);
    } 
}

 贪心思路:

把数组用折线表示,下图是我随便画的一种情况,你可以随便用折线画你假设的数组,从图中可以看出我们要要找的摆动序列长度的最大值就是一共有多少个拐点,但是连续的相同拐点只能算一个。这些拐点也叫极点,判断是不是极点的方式:该点和左区间值的差值left和和右区间的差值right相乘是否小于0,小于0则为极点,大于0说明一直都是上升趋势或下降趋势,等于0则说明是连续相等的区间。

贪心代码实现

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) return n;
        
        int ret = 0, left = 0, right = 0;
        for(int i = 0; i < n - 1; i++){ // 注意没有考虑最后一个
            right = nums[i + 1] - nums[i]; 
            if(right == 0) continue; // 先将右区间更新到拐点位置
            if(right * left <= 0) ret++; // 条件中等于0是为了第一次循环左区间为0的特殊情况
            left = right;
        }
        return ret + 1; // 要加上最后一个位置,因为最后一个位置必为极点
    }
}

6.最长递增子序列

300. 最长递增子序列 - 力扣(LeetCode)

 这道题依然会讲解动态规划和贪心两种方法思路,再在动态规划的基础上去优化得到贪心。

动态规划思路:

dp[ i ] 表示以i位置为结尾的最长递增子序列, 状态转移方程为j < i && nums[ j ] < nums[ i ] ,dp [ i ] = max( dp [ j ] + 1) 。

动态规划代码实现

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n]; // 表示以dp[i]位置结尾的最长递增子序列长度
        Arrays.fill(dp,1);
        int ret = 1;
        for(int i = 1; i < n; i++){
            for(int j = 0; j < i; j++){
                if(nums[i] > nums[j]) dp[i] = Math.max(dp[i], dp[j] + 1); // 满足条件表示i位置的值可以跟在j位置后形成递增序列
            }
            ret = Math.max(ret, dp[i]); // 更新最大值
        }
        return ret;
    }
}

时间复杂度是n²。因为多了找最合适的j位置的循环,需要想办法把这个循环省掉。根据上一题给的思路,依然可以把状态表示dp[ i ] 重新定义为在0 - i区间的最长递增子序列长度。但是依然需要考虑判断条件是跟谁比较,由于这里定义为区间内并不知道结尾的数是多少,所以新开一个数组key[i]表示在0 - i区间内最长递增子序列的最后一个数。看似很合理但是实际上状态转移方程还是写不出来的。

key[0] = nums[0];
        for(int i = 1; i < n; i++){
           if(nums[i] > key[i - 1]) { dp[i] = dp[i - 1] + 1; key[i] = nums[i]; }
           else (nums[i] < key[i - 1]) { dp[i] = dp[i - 1]; key[i] = key[i - 1]; }
        }

nums[ i ] > key[i - 1] 这种情况是可以正确写出状态转移方程的, 只需在上一个区间的最长序列长度加1即可,并且更新结尾值为当前i位置的值。但如果是小于的情况,dp[ i ] = dp[ i - 1]继续延续上一个区间的状态没错,可是 key[ i ] 的值却不能简单的用延续处理。例如数组为【10, 1 ,3】这种情况,当i = 1 的时候如果简单的把key[ i ] 的值延续上一次的状态为10,那么最终肯定是不能得到正确答案长度为2的序列1,3的。那么key[ i ] 的值在这种情况下应该怎么更新呢?你会发现需要处理很多种情况,并且只记录递增子序列最后的数根本不能应对这些情况,因为有可能最长递增子序列需要以另外一个位置为起点开头,或者说在中间把一些点替换掉。例如【9,10,1,2,3】,【1,2,11,12,5,6,7】。

贪心思路

贪心策略就是在以上思路发散扩展得来的。以示例1为例:

从左至右扫描数组,10可以看成一个单独的递增序列,长度为1。再扫描到9, 9 比 10 小,此时也能单独看成长度为1的递增序列。这时我们把10这个单独递增序列剔除掉,保留9的序列。因为在长度同样的情况下,保留越小的数,能够加在该数后形成递增的情况越多。扫描到2同理,保留2的单独序列,扫描到5,比2大,直接让长度加1,扫描到3,比2大比5小,此时可以把最长递增序列的第二位换成3,最长长度依然为2。以此类推。

通过扫描数组不断地更新每个位置的数,和添加新位置,最终得到最长递增子序列长度。

添加位置的时机:只要比最后一个位置的数大就添加位置。

更新某个位置的时机:从第一个位置依次往后比较,找到一个小于等于该数的位置,在该位置更新,更新的值为当前扫描的数。

 贪心代码实现

class Solution {
    public int lengthOfLIS(int[] nums) {
        List<Integer> list = new ArrayList<>();
        for(int x : nums){
            if(list.size() == 0) list.add(x); // 第一个数直接放入list
            else{
                if(x > list.get(list.size() - 1)) list.add(x); // 如果大于最后一个位置,直接添加放到新位置
                else{ // 否则从第一个位置开始依次比较找到放入的位置
                    for(int i = 0; i < list.size(); i++){
                        if(x <= list.get(i)) { list.set(i,x); break;} // 找到第一个小于等于的位置更新该位置的值
                    }
                }
            }
        }
        return list.size();// list的大小表示在过程中最多添加了多少位置
    }
}

优化:
在更新某个位置的数时,可以使用二分查找,快速找到该位置进行更新。需要注意的是,找出的位置是严格大于上个位置的数的,在更新left和right的时候需要注意这个细节。

class Solution {
    public int lengthOfLIS(int[] nums) {
        List<Integer> list = new ArrayList<>();
        for(int x : nums){
            if(list.size() == 0) list.add(x);
            else{
                if(x > list.get(list.size() - 1)) list.add(x);
                else{
                    int left = 0, right = list.size() - 1, mid = (left + right) / 2;
                    while(left < right){
                        if(x > list.get(mid)) left = mid + 1;
                        else if(x < list.get(mid)) right = mid;
                        else break;
                        mid = (left + right) / 2;
                    }
                    list.set(mid,x);
                }
            }
        }
        return list.size();
    }
}

结语

欢迎大家在评论区讨论留言,有不理解的地方可以私信或者评论。

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

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

相关文章

MacBook 如何设置打开json格式文件的默认程序是vs code

首先右键选中文件&#xff0c;然后选中显示简介 然后选中打开方式 设置成vs code

宝塔使用clickhouse踩坑

前言 最近有个物联网项目,需要存储物联网终端发送过来的信息(类似log日志,但又要存储在数据库里,方便后期聚合统计),本来想写文件的奈何客户要求聚合统计,所以只能用数据库才能达到更高的计算效率,当然mysql对这种日志型数据库并没有优势,数据量上去后反而不利于计算…

ML 系列:第 18 部 - 高级概率论:条件概率、随机变量和概率分布

文章目录 一、说明二、关于条件概率2.1 为什么我们说条件概率&#xff1f;2.2 为什么条件概率在统计学中很重要 三、 随机变量的定义3.1 定义3.2 条件概率中的随机变量 四、概率分布的定义五、结论 一、说明 条件概率是极其重要的概率概念&#xff0c;它是因果关系的数学表述&…

十个常见的软件测试面试题,拿走不谢

所有面试问题一般建议先总后分的方式来回答&#xff0c;这样可以让面试官感觉逻辑性很强。 1. 自我介绍 之所以让我们自我介绍&#xff0c;其实是面试官想找一些时间来看简历&#xff0c;所以自我介绍不用太长的时间&#xff0c;1-2分 钟即可。 自我介绍一般按以下方式进行介…

软考高级中哪个好考?软考5个高级资格详细分析!

计算机软件资格考试是由国家人力资源和社会保障部、工业和信息化部领导下的国家级考试&#xff0c;这个考试既是职业资格考试&#xff0c;又是职称资格考试。 软考专业资格层次对应表 计算机软件资格考试设置了27个专业资格&#xff0c;涵盖5个专业领域&#xff0c;3个级别层次…

vi —— 终端中的编辑器

目标 vi 简介打开和新建文件三种工作模式常用命令分屏命令常用命令速查图 01. vi 简介 1.1 学习 vi 的目的 在工作中&#xff0c;要对 服务器 上的文件进行 简单 的修改&#xff0c;可以使用 ssh 远程登录到服务器上&#xff0c;并且使用 vi 进行快速的编辑即可常见需要修改…

sklearn|机器学习:决策树(一)

文章目录 sklearn&#xff5c;机器学习&#xff1a;决策树&#xff08;一&#xff09;&#xff08;一&#xff09;概述&#xff08;二&#xff09;实战1. 环境配置2. sklearn 中的决策树&#xff08;1&#xff09;模块 sklearn.tree&#xff08;2&#xff09;sklearn 基本建模流…

React基础语法

1.React介绍 React由Meta公司开发&#xff0c;是一个用于构建Web和原生交互界面的库 1.1 React优势 相较于传统基于DOM开发的优势 1.组件化的开发方式 2.不错的性能 相较于其他前端框架的优势 1.丰富的生态 2.跨平台支持 1.2React的时长情况 全球最流行&#xff0c;大厂…

docker安装、设置非sudo执行、卸载

安装 sudo snap install docker 设置docker非sudo执行 sudo groupadd docker sudo usermod -aG docker $USER newgrp docker sudo chown root:docker /var/run/docker.sock 卸载docker 1.删除docker及安装时自动安装的所有包 apt-get autoremove docker docker-ce docker-…

golang的RSA加密解密

参考&#xff1a;https://blog.csdn.net/lady_killer9/article/details/118026802 1.加密解密工具类PasswordUtil.go package utilimport ("crypto/rand""crypto/rsa""crypto/x509""encoding/pem""fmt""log"&qu…

SpringSecurity框架(入门)

简介&#xff1a; Spring Security 是一个用于构建安全的 Java 应用程序的框架&#xff0c;尤其适用于基于Spring的应用程序。它提供了全面的安全控制&#xff0c;从认证&#xff08;Authentication&#xff09;到授权&#xff08;Authorization&#xff09;&#xff0c;以及…

探索C嘎嘎:初步接触STL

#1024程序员节&#xff5c;征文# 前言&#xff1a; 在前文小编讲述了模版初阶&#xff0c;其实讲述模版就是为了给讲STL提前铺垫&#xff0c;STL是C中很重要的一部分&#xff0c;各位读者朋友要知道它的份量&#xff0c;下面废话不多说&#xff0c;开始走进STL的世界。 目录&am…

使用Python进行数据分析入门

文章目录 Python环境搭建安装Anaconda验证安装 必备库介绍NumPyPandasMatplotlibSciPy 数据导入与清洗导入数据清洗数据 数据探索与分析描述性统计相关性分析 数据可视化绘制直方图 高级主题机器学习深度学习 总结 随着大数据时代的到来&#xff0c;数据分析变得越来越重要。Py…

宏组学干货|一文get宏基因组产品如何选择

大家好&#xff0c;小编来分享宏基因组产品选做思路喽~ 随着微生物研究的发展和高通量测序技术的出现&#xff0c;微生物的研究迎来了宏组学技术研究时代。目前宏组学产品种类繁多&#xff0c;常见项目主要包括宏基因组、宏病毒组和宏转录组。宏基因组项目可以检测宏样本中所有…

Elasticsearch —— ES 环境搭建、概念、基本操作、文档操作、SpringBoot继承ES

文章中会用到的文件&#xff0c;如果官网下不了可以在这下 链接: https://pan.baidu.com/s/1SeRdqLo0E0CmaVJdoZs_nQ?pwdxr76 提取码: xr76 一、 ES 环境搭建 注&#xff1a;环境搭建过程中的命令窗口不能关闭&#xff0c;关闭了服务就会关闭&#xff08;除了修改设置后重启的…

【电商搜索】现代工业级电商搜索技术-亚马逊-经典的Item-to-Item协同推荐算法

【电商搜索】现代工业级电商搜索技术-亚马逊-经典的Item-to-Item协同推荐算法 文章目录 【电商搜索】现代工业级电商搜索技术-亚马逊-经典的Item-to-Item协同推荐算法1. 论文信息2. 算法介绍3. 创新点小结4. 实验效果5. 算法结论6. 代码实现7. 问题及优化方向1. 冷启动问题2. 稀…

Windows 系统安装 Hadoop 详细教程

Hadoop 是一个分布式系统基础架构&#xff0c;在大数据处理领域有着广泛的应用。在 Windows 系统上安装 Hadoop 虽然相对复杂一些&#xff0c;但只要按照步骤来&#xff0c;也可以顺利完成。本文将详细介绍在 Windows 系统下安装 Hadoop 的过程。 一、准备工作 下载 Hadoop 安装…

如何快速使用Cesium完成项目

要快速使用Cesium完成项目&#xff0c;可以按照以下步骤进行&#xff1a; 学习基础知识&#xff1a; 首先&#xff0c;了解Cesium的基本概念和功能。可以通过阅读Cesium的官方文档和一些入门教程来掌握基础知识。例如&#xff0c;可以参考“Cesium速成教程&#xff1a;一小时入…

记录一下方便的条件编译

1. 需要准备&#xff1a; 1-1、npm i cross-env -D 是跨平台的自定义编译 1-2、构造工具&#xff1a;vite/webpack > vite: import.meta.env.VITE_NODE_ENV > webpack:process.env.NODE_ENV这里使用vite为例子 1-3、 package.json 2. 思路与步骤 首先我们知道 axio…

前端开发转行做渗透测试,通过挖漏洞来赚钱

最近&#xff0c;一个做运维的朋友在学渗透测试。他说&#xff0c;他公司请别人做渗透测试的费用是 2w/人天&#xff0c;一共2周。2周 10w 的收入&#xff0c;好香~ 于是&#xff0c;我也对渗透测试产生了兴趣。开始了探索之路~ 什么是渗透测试 渗透测试这名字听起来有一种敬…