Lotcode dynamic array exercise (724118766)

LeetCode724：

This is a problem of returning the index , And the sum of all elements on the left of the corresponding element of the index is equal to the sum of all elements on the right , This element cannot participate in the operation .

Ideas ：

      1、 First, judge whether the array is an empty array , If it is empty, it will return directly to -1.

      2、 Define a symbol for the left element and left And the symbol of the right element and right, And the symbol of the sum of elements sum.

      3、 Traverse to get the sum value of elements sum The final result of .

      4、 Traverse... Again , Start adding elements from the first phase left in . Here's a key idea , That is, the position of the return index is not added . So you need to start with the index of the second element .

      5、 After adding elements on the left every time , Remember that the elements on the right are equal to the sum sum subtract ( The left element and the corresponding index element ), Then judge whether the left and right elements are equal , Equal return index .

class Solution {
    public int pivotIndex(int[] nums) {
        if(nums==null){            //1
            return -1;
        }
        int left=0;                //2
        int right=0;
        int sum=0;
        for(int num:nums){         //3
            sum+=num;
        }
        for(int i=0;i<nums.length;i++){ //4
            if(i==0){
                left=0;
            }else{
                left+=nums[i-1];
            }
            right=sum-left-nums[i];     //5
            if(left==right){
                return i;
            }
        }
        return -1;
    }
}

LeetCode118：

This is an array topic about Yang Hui triangle . The author gives a number of lines , Let's output the result of Yang Hui triangle with so many lines , It is the sum of the two numbers above each number . For example, if you give five lines, output the following results . We can think so , Each row is equivalent to a linear table , After each row number , That is, a linear table , Continue to add the linear table as an element into a linear table .

 Input : 5
 Output :
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

 

Ideas ：

      1、 According to the figure, we can know that the first and last elements of each line are 1, Other elements are the sum of two adjacent elements above . And the number of elements in each line depends on how many lines it is now .

      2、List<Integer> Is an integer class stored in a linear table ,List<List<Integer>> Is a linear table stored in a linear table .

      3、 Create a row and column array that is the same as the incoming row , Used to store elements so that they can be put into a linear table .

      4、 Use one for loop ,I from 0~ Row number -1, Create a linear table variable every time l, Because how many elements are stored in each line depends on how many lines it is now , So define another for loop ,j from 0~i, The first and last elements of each line are equal to 1, Other elements are equal to line j Positions and j-1 Position and . Just look at the picture .

      5、 After saving the elements of each line , Put this linear table l, That is, there are variables l Put the elements in a new linear table .list.add(l).

class Solution {
    public List<List<Integer>> generate(int numRows) {
       ArrayList<List<Integer>> list = new ArrayList<List<Integer>>();
       int[][] arr = new int[numRows][numRows];
       for(int i = 0;i<numRows;i++) {
           ArrayList<Integer> l = new ArrayList<Integer>();
           for(int j = 0;j<=i;j++) {
               if(j == 0 || j == i) {
                   arr[i][j] = 1;
               }else {
                   arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
               }
               l.add(arr[i][j]);
           }
           list.add(l);
       }
       return list;
    }
}

LeetCode766：

This is a matrix topic , A matrix is required , If all the elements of the positive diagonal are equal, it returns true, Unequal return false.

Below is a thought map of this problem .

Ideas ：

      1、 From this picture, we can know , There are two paths , One is matrix[0][0] Go right , The other is going down . To the left is the number of columns col Move , Down is the number of rows row Move . Every time we have to judge whether the elements on the diagonal are equal , In fact, each element is added in rows and columns 1.

await a vacancy or job opening ：