[算法]Leetcode3487

题目描述

初步思路:

1.我要做的就是构建好删除逻辑
2.第一个思路是remove掉重复的元素,第二个思路是用一个ixnde数组放置新的数组,也可以直接把重复的元素保留一个,其余置为0也可以.

第一次的代码解释

class Solution {
    public int maxSum(int[] nums) {

        //java获取长的代码
        int length = nums.length;
        //定义一个数组
        int i = 0;
        int sum = 0;
        for(i=0;i < length-1;i++){
            if(nums[i]>=0){
                sum+=nums[i];
            }
            else continue;
        }
        return sum;
    }
}

最后的结果是显示,10而不是15,为什么呢?

思考1:continue错误了吗?
continue是跳过本次循环,继续下一次循环,而不是跳出循环

思考2:
案例分析:

意识到没有去重

1.自己的代码没有考虑到重复的元素是不能进行计算的,也就是说我们需要先把里面的元素进行去重操作

//去重
//方法1
// 所有的元素都和其他的元素比较
//借助双指针比较
for(int i = 0;i < length-1;i++){
    for(int j = i+1;j < length;j++){
        if(nums[i] == nums[j]){
            nums[j] = 0;
        }
    }
}

//改进后
class Solution {
    public int maxSum(int[] nums) {
        

        //java获取长度代码
        int length = nums.length;
        //定义一个数组
        // int i = 0;
        int sum = 0;

        //先进性去重

        for(int z = 0;z < length-1;z++){
            for(int j = z+1;j < length;j++){
                if(nums[z] == nums[j]){
                nums[j] = 0;
        }
    }
}

        for(i=0;i < length-1;i++){
            if(nums[i]>=0){
                sum+=nums[i];
            }
            else continue;
        }
        return sum;
    }
}

第二段代码中,我把我的代码先进性驱虫了
结果如下!

发现除了第一个测试用例,另外两个都跑通了,这是为什么呢?

思考原因

这里面,1,2,3,4,5加起来应该是15,而结果是10,唯一的可能就是5没有加进来,那么为什么呢?

题目提示之后发现代码存在问题

没有考虑代码的全部元素都是负数的情况,也就是姚新加入一个逻辑,如果说我的元素里面全部都是负数的话,那么最大的那么元素就是我们想要的元素了.

但是我们如何表示所有的元素都是负数吗,还得是一个个遍历啊

//代码判断是否为负数


for(int h = 0; h < length -1;h++){
    if(nums[i]>0){
        boolean t = true;
    }
    else {
        t = false;
    }
        
}
//只要有一个数是大于0的数,

然后还需要配合写一个返回最大值的函数(如果全是负数的情况)

public int max(int[] A){
    int length = A.length;
        int max = A[0];
        for (int i = 0;i<length - 1;i++)
        {
            if(A[i] < A[i+1])
            max = A[i+1];
        }
        return max;
    }

第三次提交

class Solution {
    public int max(int[] A){
    int length = A.length;
    max = nums[0];
        for (int i = 0;i<length - 1;i++)
        {
            if(nums[i] < nums[i+1])
            max = nums[i+1]
        }
        return max;
    }
    public int maxSum(int[] nums) {
        boolean t = false;
        for(int h = 0; h < length -1;h++){
         if(nums[i]>=0){
            boolean t = true;
            //一个大于0就可以用之前的方法
        }
        else {
            t = false;
      }
      if(t = true){//全部都是
              //java获取长度代码
        int length = nums.length;
        //定义一个数组
        // int i = 0;
        int sum = 0;

        //先进性去重

        for(int z = 0;z < length-1;z++){
            for(int j = z+1;j < length;j++){
                if(nums[z] == nums[j]){
                nums[j] = 0;
        }
    }
}

        for(i=0;i < length-1;i++){
            if(nums[i]>=0){
                sum+=nums[i];
            }
            else continue;
            }
        
            
        }
        else if(t = false)
        sum = max(nums)
        }

    }
    return sum;
}

编译出错

借助AI

发现我的最大值代码逻辑搞错了,但是思路方向是想对了
https://www.kimi.com/chat/d21frhts8fb0hlq4lgog

//最终代码
class Solution {
   public int maxSum(int[] nums) {
       int length = nums.length;

       // 去重：把重复值设为0
       for (int z = 0; z < length - 1; z++) {
           for (int j = z + 1; j < length; j++) {
               if (nums[z] == nums[j]) {
                   nums[j] = 0;
               }
           }
       }

       int sum = 0;
       int maxNeg = Integer.MIN_VALUE;

       // 遍历去重后的数组
       for (int i = 0; i < length; i++) {
           if (nums[i] >= 0) {
               sum += nums[i];
           } else {
               maxNeg = Math.max(maxNeg, nums[i]);
           }
       }

       // 如果 sum 为 0 且存在负数，返回最大负数
       if (sum == 0 && maxNeg != Integer.MIN_VALUE) {
           return maxNeg;
       }

       return sum;
   }
}
//这段代码先尽量把非负数都加起来；如果加完以后总和还是 0，说明要么没选到任何非负数、要么正数被负数完全抵消，这时就去拿最大的那个负数作为答案。

≥0 的数字：统统加到 sum 里（正数、0 都算上）。
负数：放到「最大负数」这一堆里，每次把较大的那个留下（就是 maxNeg）。
等循环走完，你就得到：
sum：所有非负数的总和（可能为 0）。
maxNeg：最大的那个负数（如果没负数，就还是 Integer.MIN_VALUE）。
后面再用这两个结果决定最终答案。

最优解:

哈希表,统计所有元素的次数,所有的元素,都只会相加一次,如果全部是负数的话,那么就用最大的元素作为结果即可