2021-11-23每日刷题打卡

2021-11-23每日刷题打卡

力扣——每日一题

859. 亲密字符串

给你两个字符串 s 和 goal ，只要我们可以通过交换 s 中的两个字母得到与 goal 相等的结果，就返回 true ；否则返回 false 。

交换字母的定义是：取两个下标 i 和 j （下标从 0 开始）且满足 i != j ，接着交换 s[i] 和 s[j] 处的字符。

例如，在 “abcd” 中交换下标 0 和下标 2 的元素可以生成 “cbad” 。

示例 1：

输入：s = “ab”, goal = “ba”
输出：true
解释：你可以交换 s[0] = ‘a’ 和 s[1] = ‘b’ 生成 “ba”，此时 s 和 goal 相等。

这题要注意一点，就是必须而且只能交换两个字符，也就是说你哪怕一开始就相等了，但你也得进行一次交换，如果交换完后不一样了，那你这个就不满足条件，返回false，比如ab和ab，但aa和aa这样，交换后还是一样的情况就满足条件返回true。你现在也能注意到，我只要交换两个一样的字母就行了，只要两个字母一样，交换和还是一样的。所以我们在遍历字符串的同时要把s的组成情况记录下来。

先判断两个字符串长度是否相等，如果不相等就直接返回false，准备一个pos=-1来记录找到的字符，然后双指针比较两个字符串，找到第一个不一样的地方就把位置记录下来，然后继续遍历找第二个不一样的，要是找到了就把当前的字符和刚刚找到的字符交换一下，然后之间结束循环，每次遍历的时候把s的字符设定一个哈希表存起来。循环结束后判断pos是否为-1，如果为-1说明s和goal两个字符串完全一样，然后我们查看哈希表，看看s里面有没有两个一样的字符，如果有就返回true，没有就返回false。如果不为-1我们就比较两个字符串是否相等，相等就返回true，不相等就返回false。

class Solution {
public:
    bool buddyStrings(string s, string goal) {
        int l=0,r=0,n=s.size(),m=goal.size(),pos=-1;
        if(n!=m)return false;
        unordered_map<char,int>mymap;
        while(l<n)
        {
            if(s[l]!=goal[r]&&pos==-1)pos=l;
            else if(s[l]!=goal[r])
            {
                swap(s[l],s[pos]);
                break;
            }
            mymap[s[l]]++;
            l++,r++;
        }
        if(pos==-1)
        {
            for(auto i:mymap)
                if(i.second>1)return true;
            return false;
        }
        return s==goal?true:false;
    }
};

392. 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = “abc”, t = “ahbgdc”
输出：true

双指针遍历，一个l遍历s，一个r遍历t，当l大于s.size()活r大于t.size()时结束遍历，每次遍历判断s[l]和t[r]是否相等，如果不相等r++,如果相等l和r一起++。当遍历结束后判断一下l是否走完了s，如果走完了说明可以在t中找到s的所有字母，即s为t子序列返回true。如果没找完返回false。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int l=0,r=0,n=s.size(),m=t.size();
        while(l<n&&r<m)
        {
            if(s[l]==t[r])l++,r++;
            else r++;
        }
        if(n==l)return true;
        return false;
    }
};

349. 两个数组的交集和350. 两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

这两题挺像的，只不过前面是不能出现重复元素，后面可以出现重复元素。

先对nums1和nums2排序，然后双指针遍历比较，当nums1[l]==nums2[r]时，把数值插入准备好的vector容器v里，如果nums[l]小了就l++，反之r++。

如果不能出现重复元素，可以在插入的时候做个判断，如果v不为空而且v尾部元素和即将插入的数相等，就不插入。因为我们对两个nums都进行了排序，所以v中的元素也是排序好的，所以只判断尾部元素就可以。如果可以出现重复元素就不用加这一步。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        vector<int>v;
        int l=0,r=0,n=nums1.size(),m=nums2.size();
        while(l<n&&r<m)
        {
            if(nums1[l]==nums2[r])
            {
                if(v.size()&&nums1[l]!=v.back())
                    v.push_back(nums1[l]);
                else if(!v.size())v.push_back(nums1[l]);
                l++,r++;
            }
            else if(nums1[l]>nums2[r])r++;
            else if(nums1[l]<nums2[r])l++;
        }
        return v;
    }
};

42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

首先我们知道，只有中间的高度小于左右两边的高度才可以接到雨水，这种情况下我们可以使用头尾双指针向中间移动遍历。准备两个值l_max和r_max，来存左右两边的最大高度。开始遍历，每次比较height[l]和heigh[r]的大小，如果l大那就可以知道左边已经出现了大于当前高度的地方，只要在右边找到大于当前高度的地方即可，我们先更新一下最大高度，看是r_max大还是height[r]大，如果height[r]大就更新一下r_max，我们计算r_max-heigh[r]的值即为我们可以接到雨水的值，如果当前我们遍历到的柱子就是最高的柱子，那自然右边不会出现更高的柱子来让我们接雨水，所以是0，如果r_max大于heigh[r]则说明右边也有高的柱子，满足了中间小两边大的条件，此时能接雨水的容量就是r_max-heigh[r]，然后r–。如果是l小了则以上操作改一下即可。

class Solution {
public:
    int trap(vector<int>& height) {
        int l=0,r=height.size()-1,l_max=0,r_max=0,ans=0;
        while(l<r)
        {
            if(height[l]<height[r])
            {
                l_max=max(l_max,height[l]);
                ans+=l_max-height[l];
                l++;
            }
            else
            {
                r_max=max(r_max,height[r]);
                ans+=r_max-height[r];
                r--;
            }
        }
        return ans;
    }
};