七月集训 (第01天) —— 数组

前言

        此为《英雄算法联盟：算法集训》的内容，具体内容详见：知识星球：英雄算法联盟 - 六月集训。加入星球后，即可享用星主 CSDN付费专栏 免费阅读 的权益。
        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        希望大家先自己思考，如果实在没有想法，再看下面的算法思路，如果有思路但是写不出来，可以参考朋友圈中其他人的代码，总有一款是适合你的，关注一下他，取其之长，补给之短。
        今天集训的内容是：数组
        今天的题比较简单，务必跟上。

一、练习题目

题目链接	难度
2319. 判断矩阵是否是一个 X 矩阵	★☆☆☆☆
599. 两个列表的最小索引总和	★☆☆☆☆
674. 最长连续递增序列	★☆☆☆☆
989. 数组形式的整数加法	★☆☆☆☆

二、算法思路

1、判断矩阵是否是一个 X 矩阵

        （1）对于主对角线来说，横坐标和纵坐标相等；对于副对角线来说，横坐标+纵坐标的值等于矩阵的行数减一；
        （2）所以，只需要通过判断是否是主对角线，或者副对角线，如果是，则判断格子是否为 0，为 0 则返回 false；如果不是，则判断格子是否为 非0，非0 则返回 false；

class Solution {
public:
    bool checkXMatrix(vector<vector<int>>& grid) {
        int n = grid.size();
        int i, j;
        for(i = 0; i < n; ++i) {
            for(j = 0; j < n; ++j) {
                if(i == j || i + j == n - 1) {
                    if( !grid[i][j] ) {
                        return false;
                    }
                }else {
                    if( grid[i][j] ) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
};

2、两个列表的最小索引总和

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

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        int i, j;
        int ans, min = 10000000;
        vector<string> str;
        for(i = 0; i < list1.size(); ++i) {
            for(j = 0; j < list2.size(); ++j) {
                if(list1[i] == list2[j]) {
                    ans = i + j;
                    if(ans < min) {
                        min = ans;
                        str = { list1[i] };
                    } else if(ans == min) {
                        str.push_back( list1[i] );
                    }
                }
            }
        }
        return str;
    }
};

3、最长连续递增序列

        （1）这题其实是最简单的动态规划思想；
        （2）用 ans[i] 表示以第 i 个元素结尾的最长递增连续子序列，注意，这里有个连续，所以问题就变得简单了。
        （3）如果 nums[i-1] < nums[i] ，那么当前这个数连接到前一个数，一定是最优的；否则，当前这个数只能自己作为单独的序列；最后取一个最大值就是我们要求的解了。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int ans[100010];
        int i;
        int ret = 1;
        ans[0] = 1;
        for(i = 1; i < nums.size(); ++i) {
            if(nums[i-1] < nums[i]) {
                ans[i] = ans[i-1] + 1;
            }else {
                ans[i] = 1;
            }
            ret = max(ret, ans[i]);
        }
        return ret;
    }
};

4、数组形式的整数加法

        （1）数组的低位用来存储数字的低位，这样相加的时候可以对齐；
        （2）所以，首先将 nums 进行逆序；
        （3）然后将 k 进行各位拆解，放入 add 数组；
        （4）然后对两个数组实现各位的相加，并且记录每一位相加得到的进位 carry（注意：相加的时候需要加上上一位的进位）；
        （5）如果数组相加完毕，最后进位非0，则需要添加一位，考虑 9999 + 1 的情况；
        （6）最后别忘了将相加的数组再进行一次逆序；

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& nums, int k) {
        vector<int> add;
        vector<int> ret;
        int i;
        reverse(nums.begin(), nums.end());
        while(k) {
            add.push_back( k%10 );
            k /= 10;
        }
        int maxlen = max(nums.size(), add.size());
        int carry = 0;
        for(i = 0; i < maxlen; ++i) {
            int a = i<nums.size() ? nums[i] : 0;
            int b = i<add.size() ? add[i] : 0;
            int now = (a + b + carry) % 10;
            carry = (a + b + carry) / 10;
            ret.push_back(now);
        }
        if(carry) ret.push_back(carry);
        reverse(ret.begin(), ret.end());
        return ret;
    }
};