7月算法训练------第一天（数组）解题报告

7月算法训练------第一天（数组）解题报告

题目类型：数组
题目难度：简单

第一题、2319. 判断矩阵是否是一个 X 矩阵

题目链接：2319. 判断矩阵是否是一个 X 矩阵
思路分析：

对数组进行遍历，当 i== j或i+j == grid[0].length时，如果grid[i][j] == 0，那么直接返回false；
其他情况时，如果grid[i][j] != 0，那么直接返回false。
当对数组遍历完之后，返回true。
代码：

class Solution {
    public boolean checkXMatrix(int[][] grid) {
        int len = grid[0].length;
        for(int i = 0; i < len; i++){
            for(int j = 0; j < len; j++){
                if(i == j || i + j == len - 1){
                    if(grid[i][j] == 0){
                        return false;
                    }
                }else{
                    if(grid[i][j] != 0){
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

第二题、599. 两个列表的最小索引总和

题目链接：599. 两个列表的最小索引总和
思路分析：
用一个HashMap存储list1中的String和索引号，然后遍历list2，如果HashMap中包含list2，那么就记录list1的索引号和list2的索引号，
如果二者（list1的索引号和list2的索引号）之和小于indexMin，就将原来的HashMap清空，并将当前的字符串放入ArrayList中；
如果二者（list1的索引号和list2的索引号）之和等于indexMin，不对HashMap做任何处理，直接将当前字符串放入ArrayList中；
如果二者（list1的索引号和list2的索引号）之和大于indexMin，不做任何处理。

技巧：
向HashMap中放入键值对：map.put(key, value);
得到HashMap中提取值：map.get(key);
判断HashMap中是否含有键：map.containsKey(key)
清空ArrayList：list.clear();
ArrayList，方法：toArray(T[] a) ,返回值：<T> T[]
返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一到最后一个元素）；返回数组的运行时类型是指定的数组的运行时类型。

class Solution {
    public String[] findRestaurant(String[] list1, String[] list2) {
        Map<String, Integer> ma = new HashMap();
        int s = 0, indexMin = list1.length + list2.length;
        // String[] str = new String[1];
        List<String> str = new ArrayList();
        for(int i = 0; i < list1.length; i++){
            ma.put(list1[i], i);
        }
        for(int j = 0; j < list2.length; j++){
            if(ma.containsKey(list2[j])){
                s = ma.get(list2[j]);
                if(indexMin > s + j){
                    indexMin = s + j;
                    str.clear();
                    str.add(list2[j]);
                }else if(indexMin == s + j){
                    str.add(list2[j]);
                }
            }
        }
        return str.toArray(new String[str.size()]);
    }
}

第三题、674. 最长连续递增序列

题目链接：674. 最长连续递增序列
思路分析：
用双指针，当右指针下一个数大于右指针时，就将更新max值；
当右指针的下一个数小于右指针数时，就更新左指针，将左指针更新至右指针下一个数，右指针也更新到下一个数；
当相等时，就将max值置1（这里考虑不全面，导致有点bug，之后再改改）
代码：

class Solution {
//不能经过所有测试用例
    public int findLengthOfLCIS(int[] nums) {
        if(nums.length <= 1){
            return nums.length;
        }
        int l = 0, r = 0, i = 1, max = 0;
        while(r < nums.length-1){
            if(r + 1 < nums.length) {
                i = i + 1;
                if (nums[i] > nums[r]) {
                    r = i;
//                    i = i + 1;
                    int len = r - l;
                    max = Math.max(len, max);
                } else if (nums[i] < nums[r]) {
                    l = i;
                    r = l;
                } else {
                    max = 1;
                }
//                 r++;
            }
            
        }
        return max+1;
    }
}

第四题、989. 数组形式的整数加法

题目链接：989. 数组形式的整数加法
思路分析：
本题可套用模板，固定套路：

while ( A 还有数 || B 还有数)
    记录A 的当前位
    记录B 的当前位
    
    和 = A 的当前位 + B 的当前位 + 进位carry
    
    当前位 = 和 % 10;
    进位carry= 和 / 10;
    
判断是否有进位carry

代码：

class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
        List<Integer> list2 = new ArrayList();
        int len = num.length;
        int i = len - 1,carry = 0,sum = 0;
        while(i >= 0 || k != 0){
            int x = i >= 0 ? num[i] : 0;
            int y = k != 0 ? k % 10 : 0;

            sum = x + y + carry;
            
            k = k / 10;
            carry = sum / 10;
            list2.add(0, sum%10);
            i--;
            
        }
        if(carry != 0){
            list2.add(0, carry);
        }
        return list2;

    }

}