七月集训 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;
    }
};

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;
    }
};

优化

使用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;
    }
};

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;
    }
};

思路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;
    }
};

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;
    }
};

思路2

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值