leetcode题笔记

最新想坚持每天刷leetcode题目，并且做相应的笔记，拓宽自己的思路，能够在工作中用到，同时记录相应笔记，希望自己能一直坚持下去！！

1、1672.最富有客户的资产总量 给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量

输入：accounts = [[1,2,3],[3,2,1]] 输出：6 解释： 第 1 位客户的资产总量 = 1 + 2 + 3 = 6 第 2 位客户的资产总量 = 3 + 2 + 1 = 6 两位客户都是最富有的，资产总量都是 6 ，所以返回 6

我的思路： 二维数组，遍历所有二维数组，求出每一个一维数组的总和，把它放到一个新的集合中，然后求这个集合的最大值。（耗时1ms,消耗空间38MB） 类似思路，定义accounts.length大小的数组，二重遍历，将数据给数组，再求数组中的最大值。

class Solution {
    public int maximumWealth(int[][] accounts) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < accounts.length; i++){
            int sum = 0;
            for(int j=0; j<accounts[i].length; j++){
                sum += accounts[i][j];
            }
            list.add(sum);
        }
        return Collections.max(list);
    }
}

其他人的思路： 1、 定义一个int数，每次遍历完，进行对比，最后返回最大的数。（耗时0ms,消耗空间38.2MB）

public class Solution {
    public int maximumWealth(int[][] accounts) {
            int allSum = 0;
            for(int i = 0;i < accounts.length ;i++)
            {
                int sum = 0;
                for(int j = 0; j < accounts[0].length; j++)
                {
                    sum += accounts[i][j];
                }
                if(sum >= allSum){
                    allSum = sum;
                }
            }

        return allSum;
    }
}

2、JDK8的流式接口**（耗时5ms,耗费空间37.9MB）**

public class Solution {
    public int maximumWealth(int[][] accounts) {
        return Arrays.stream(accounts).map(ints ->
                Arrays.stream(ints).sum()
        ).max(Integer::compareTo).get();
    }

}

2、1480.一维数组的动态和 给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。 请返回 nums 的动态和。

示例 1： 输入：nums = [1,2,3,4] 输出：[1,3,6,10] 解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。

我的思路： 定义一个新数组（长度和原数组一样）和一个sum，循环原来的数组，每次sum都相加一次，第一次循环直接将数据放到新数组中，后面依次存放sum,最后返回数据。 (耗时0ms,耗费内存38.4MB)

class Solution {
    public int[] runningSum(int[] nums) {
        int[] newnums = new int[nums.length];
        int sum = 0;
        for(int i = 0; i < nums.length ; i++){
            sum += nums[i];
            if(i == 0){
                newnums[0] = nums[0];
            }else{
                newnums[i] = sum;
            }
            
        } 
        return newnums;
    }
}

其他人的思路： 1、动态求和公式：temp[i] = temp[i-1] + nums[i]; (耗时0ms,耗费内存38.6MB)

class Solution {
     public int[] runningSum(int[] nums) {
         int temp[] = new int[nums.length];
         temp[0] = nums[0];
         for(int i = 1;i < nums.length ;i++){
             temp[i] = temp[i-1] + nums[i];
         }
         return temp;
     }
 }

2、改变参数的数组，代码比较简单 (耗时0ms,耗费内存38.7MB)

class Solution {
    public int[] runningSum(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            nums[i] += nums[i - 1];
        }
        return nums;
    }
}