七月集训 day01（数组）

2319. 判断矩阵是否是一个 X 矩阵

题目

链接：https://leetcode.cn/problems/check-if-matrix-is-x-matrix/

思路：

1-判断是否是矩阵对角线上的元素
主对角线上的元素满足：i == j
副对角线上的元素满足：i + j == 矩阵的行数 - 1；

2-解题思路
01-如果是矩阵对角线上的元素且为0的话就返回false
02-如果不是矩阵上的元素且为非0的话就返回false
如果以上两个条件都不满足，则返回true

代码

class Solution {
public:
    bool checkXMatrix(vector<vector<int>>& grid) {
        int len = grid.size();
        for(int i = 0; i < len; i++)
        {
            for(int j = 0; j < len; j++)
            {
                //先判断是不是对角线上的元素
                if(i == j || i + j == len - 1)
                {
                    //如果是对角线上的元素,并且该元素是0，则返回false
                    if(!grid[i][j])
                    {
                        return false;
                    }
                }
                //如果是矩阵中的其他元素
                else
                {
                    //只要找到一个非0元素则返回false
                    if(grid[i][j])
                    {
                        return false;
                    }
                }
            }
        }
        //如果以上条件都不满足，则返回true
        return true;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

599. 两个列表的最小索引总和

题目

链接 https://leetcode.cn/problems/minimum-index-sum-of-two-lists/

思路

两重遍历，如果遍历到的两个字符串相等，则计算他们的索引和，取索引和最小的字符串，如果出现相等的，则一并加入字符串集合中。

代码

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        int res, min = 2000;
        vector<string> str;
        for(int i = 0; i < list1.size(); i++)
        {
            for(int j = 0; j < list2.size(); j++)
            {
                if(list1[i] == list2[j])
                {
                    res = i + j;
                    if(res < min)
                    {
                        min = res;
                        str = { list1[i] };
                    } 
                    else if(res == min)
                    {
                        str.push_back( list1[i] );
                    }
                }
            }
        }
        return str;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

优化

使用hash

代码

没太看懂

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        int ans, min = 20000;
        vector<string> str;
        unordered_map<string, int> string2Index;
        for(int i = 0; i < list1.size(); i++)
        {
            if(string2Index.find( list1[i] ) == string2Index.end())
            {
                string2Index[ list1[i] ] = i;
            }
        }

        for(int j = 0; j < list2.size(); j++)
        {
            if(string2Index.find( list2[j] ) != string2Index.end())
            {
                ans = string2Index[ list2[j] ] + j;
                if(ans < min)
                {
                    min = ans;
                    str = { list2[j] };
                } 
                else if (ans == min)
                {
                    str.push_back( list2[j] );
                }
            }

        }
        return str;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

674. 最长连续递增序列

题目

链接 https://leetcode.cn/problems/longest-continuous-increasing-subsequence/

思路1 双指针

最小的连续位数为1，两重循环遍历，不断更新最长连续字串，最后取大的就可以得到答案

代码

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int res = 0;
        int count = 1;
        int len = nums.size();
        for(int i = 0; i < len; i++)
        {
            for(int j = i + 1; j < len; j++)
            {
                if(nums[j] > nums[j - 1])
                {
                    count++;
                }
                else
                {
                    break;
                }
            }
            if(count > res)
            {
                res = count;
            }
            count = 1;
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

思路2

遍历一次，用一个数组记录最长连续子串，在遍历的过程中不断更新最长的子串。类似dp

代码

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int ans[100010];
        int res = 1;
        //用一个数组保存最长的连续子串位数
        ans[0] = 1;
        for(int i = 1; i < nums.size(); i++)
        {
            if(nums[i - 1] < nums[i]) 
            {
                ans[i] = ans[i - 1] + 1;
            } 
            else
            {
                ans[i] = 1;
            }
            //每次不断更新最长子串结果
            res = max(res, ans[i]);
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

989. 数组形式的整数加法

题目

思路1

1-数组的低位用来存储数字的低位，这样相加时可以对齐
2-所以，首先将nums进行逆序
3-然后将k进行各位拆解，放入add数字中
4-然后对两个数组实现各位的相加，并且记录每一位相加得到的进位carry（注意：相加的时候要加上上一位的进位）；
5-最后将得到的数组逆序就是答案

代码

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& num, int k) {
        vector<int> add;
        vector<int> ret;

        reverse(num.begin(), num.end());

        //把k按位存入add数组
        while(k)
        {
            add.push_back( k % 10);
            k /= 10;
        }

        int maxlen = max(num.size(), add.size());
        int carry = 0;

        for(int i = 0; i < maxlen; i++)
        {
            //取出各数组中的每一位元素，没有就为0
            int a = i < num.size() ? num[i] : 0;
            int b = i < add.size() ? add[i] : 0;

            //当前位置的新元素
            int now = (a + b + carry) % 10;
            
            //更新进位
            carry = (a + b + carry) / 10;
            //push_back:将元素存入数组的末尾
            ret.push_back(now);
        }
        //1 + 999 如果最后一位有进位，需要将其加入数组末尾
       if(carry)
       {
           ret.push_back(carry);
       }
       reverse(ret.begin(), ret.end());
       return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

思路2

将数组中元素取出为整数，与目标数字直接加和得到答案的整数，在把这个整数按位存回数组就可以。