周总结：2021-11-22——11-28

周总结：2021-11-22——11-28

这里是这一周来刷题时印象比较深的几道题，挑出来做个总结

384. 打乱数组

给你一个整数数组 nums ，设计算法来打乱一个没有重复元素的数组。

实现 Solution class:

Solution(int[] nums) 使用整数数组 nums 初始化对象
int[] reset() 重设数组到它的初始状态并返回
int[] shuffle() 返回数组随机打乱后的结果

示例：

输入
[“Solution”, “shuffle”, “reset”, “shuffle”]
[[[1, 2, 3]], [], [], []]
输出
[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]

解释
Solution solution = new Solution([1, 2, 3]);
solution.shuffle(); // 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。例如，返回 [3, 1, 2]
solution.reset(); // 重设数组到它的初始状态 [1, 2, 3] 。返回 [1, 2, 3]
solution.shuffle(); // 随机返回数组 [1, 2, 3] 打乱后的结果。例如，返回 [1, 3, 2]

不知道这题有什么意义，但这次学到了个叫做洗牌算法的东西，就是随机的打乱一个数组，每次打乱的地方都不一样。

这个洗牌算法就是，for循环从下标0开始遍历，生成一个随机数，范围是0~数组长度内，然后每次把下标为i的元素和下标为随机数的元素交换，这样就是随机打乱了数组，把数组遍历完后得到的就是随机打乱的数组了，因为随机数生成每个数的概率都是一样的，所以打乱的也是随机的不会有换了好几次结果都是一样的情况发生。

class Solution {
public:
    vector<int>v;
    vector<int>v1;
    Solution(vector<int>& nums) {
        v=nums;
        v1=nums;
    }
    
    vector<int> reset() {
        v=v1;
        return v;
    }
    
    vector<int> shuffle() {
        int n=v.size();
        for(int i=0;i<n;i++)
        {
            int a=(i+rand()%n)%n;
            int temp=v[a];
            v[a]=v[i];
            v[i]=temp;
        }
        return v;
    }
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution* obj = new Solution(nums);
 * vector<int> param_1 = obj->reset();
 * vector<int> param_2 = obj->shuffle();
 */

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

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