100.LeetCode 热题 100---4-7

4.移动零

这个简单就是借一个temp中间量来作互换

public class gao {
    public static void main(String[] args) {
        int nums[] = {0, 1, 0, 3, 12};
//        int nums[] = {1, 0, 0, 3, 12,0};
//        int nums[] = {0};
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] == 0 && nums[j] != 0) {
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                }
            }
        }
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
}

5.盛最多水的容器

找到最大边和次最大边不难 也就是它们中间包的东西

        int height[] = {1, 8, 6, 2, 5, 4, 8, 3, 7};
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < height.length; i++) {
            for (int j = i + 1; j < height.length; j++) {
                if (height[i] < height[j]) {
                    break;
                } else {
                    while (height[i] >= height[j]) {
                        map.put(j-i,height[j]);
                        break;
                    }
                }
            }
        }

难的是 得到集合后 如何求出它俩中间(包括它俩)包的总共多少个点
这样可以得到7*7 我的脑袋就到这想不了了
然后借鉴学习

      int maxKey=0;
      //map.ketSet() 方法将获取 Map 集合的所有键名 并存放在一个 Set 集合对象中
      for(int key: map.keySet()){
          if(key>maxKey){
              maxKey=key;
          }
      }
        System.out.println(maxKey*map.get(maxKey));

大致意思是这样的

6.三数之和

这个找出来所有符合
i != j、i != k 且 j != k
nums[i] + nums[j] + nums[k] == 0
这两个条件一点都不难 甚至都称不上算法

    HashMap<Integer, ArrayList> map = new HashMap<>();
        int a = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                for (int k = j + 1; k < nums.length; k++) {
                    if (nums[i] + nums[j] + nums[k] == 0) {
//                        System.out.println(i + " " + j + " " + k);
                        ArrayList<Integer> list = new ArrayList<>();
                        list.add(nums[i]);
                        list.add(nums[j]);
                        list.add(nums[k]);
                        map.put(a, list);
                        a++;
                    }
                }
            }
        }
        System.out.println(map);

难就难在 如何去掉重复的 例如：

我脑子想到过用Set去重 不过并未实现
借助DeepSeek的想法 就是得到三元组后 排序 然后使用HashSet去重

class zhengjiao {
    public List<List<Integer>> fangfa(int[] nums) {
        // 使用HashSet存储去重的三元组（每个三元组是排序后的List）
        Set<List<Integer>> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                for (int k = j + 1; k < nums.length; k++) {
                    if (nums[i] + nums[j] + nums[k] == 0) {
                        // 创建三元组并排序
                        List<Integer> triplet = Arrays.asList(nums[i], nums[j], nums[k]);
                        Collections.sort(triplet); // 排序，使相同三元组变成相同顺序
                        set.add(triplet); // HashSet自动去重
                    }
                }
            }
        }
        // 将Set转换为List<List<Integer>>输出
        List<List<Integer>> result = new ArrayList<>(set);
        return result; // 输出: [[-1, -1, 2], [-1, 0, 1]]
    }
}

只不过时间复杂度高 网上更多的是双指针法 脑子笨就像出来这个

不过人家没要求算法的复杂度优化

7.接雨水

这道题确实giao 我本身还去找啥规律的凑出来 实际上想法不对
就学习他人了 两个方法 一个双指针法 一个去重法

class Solution {
    //双指针法
    public int trap(int[] height) {
        int ans = 0;
        int left = 0, right = height.length - 1;
        int leftMax = 0, rightMax = 0;
        while (left < right) {
            leftMax = Math.max(leftMax, height[left]);
            rightMax = Math.max(rightMax, height[right]);
            if (height[left] < height[right]) {
                ans += leftMax - height[left];
                ++left;
            } else {
                ans += rightMax - height[right];
                --right;
            }
        }
        return ans;
    }
}

参考官方 就是一个一个从左右两边数 然后累加

第二个方法确实牛 也难想象

class Solution2 {
    //去重叠法
    public int trap(int[] height) {
        int l_max = 0, r_max = 0, ans = 0;
        for (int i = 0; i < height.length; i++) {
            l_max = Math.max(l_max, height[i]);
            r_max = Math.max(r_max, height[height.length - i - 1]);
            ans += l_max + r_max - height[i];
        }
        return ans - l_max * height.length;
    }
}

我大致理解的就是把 左边所有的加起来+右边所有的加起来（实际上就是两遍柱子+左右光影）然后再减去整个图形3*12（也就是 右边一遍柱子+右光影+左一部分光影）
最后减去左边柱子 便得到了可乘的雨水

只能说算法的世界确实精彩 不仅要你逻辑思维能力其实也就是数学能力 还有代码的实现 好好学吧 就是个菜鸟