LeetCode [1389 ~ 1392]

链接：https://leetcode-cn.com/contest/weekly-contest-181/
来源： LeetCode

1389. 按既定顺序创建目标数组(签到)

  思路：因为给出了插入的位置，那个当前的数字只要一插入数组中，那么在当前位置的前面的数值的位置有大于等于当前位置的都后向后移动，也就是位置值加一。

class Solution {
public:
    vector<int> createTargetArray(vector<int>& nums, vector<int>& index) {
        int n = nums.size();
        vector<int> ans(n);
        for (int i = 0; i < n; ++ i) {
            for (int j = 0; j < i; ++ j) {
                if (index[j] >= index[i]) index[j] += 1;
            }
        }
        for (int i = 0; i < n; ++ i) ans[index[i]] = nums[i];
        return ans;
    }
};

1390. 四因数(数学)

  思路：首先判断当前值的因子个数是否为 4 个，如果是那么就计算各个因子之和即可。

class Solution {
public:
    bool check(int x) {
        int cnt = 2;
        for (int i = 2; i * i <= x; ++ i) {
            if (x % i == 0) {
                if (i * i == x) cnt ++;
                else cnt += 2;
            }
        }
        return cnt == 4;
    }
    int cal(int x) {
        int res = x + 1;
        for (int i = 2; i * i <= x; ++ i) {
            if (x % i == 0) {
                if (i * i == x) res += i;
                else res += i + x / i;
            }
        }
        return res;
    }
    int sumFourDivisors(vector<int>& nums) {
        int n = nums.size(), ans = 0;
        for (int i = 0; i < n; ++ i) {
            if (check(nums[i])) {
                ans += cal(nums[i]);
            }
        }
        return ans;
    }
};

1391. 检查网格中是否存在有效路径(思维 + 并查集)

  思路：官网题解给了一个非常巧妙的思想，首先我们把每一个网格都拆成 4 个方向，上，右，下，左，分别对应 0，1，2，3。

此时我们可以发现，如果保证能够走向相邻的位置：
0 号位置如果是 1，那么它的上方的值的 2 号位置必须是 1。
1 号位置如果是 1，那么它的右侧的值的 3 号位置必须是 1。
2 号位置如果是 1，那么它的下方的值的 0 号位置必须是 1。
3 号位置如果是 1，那么它的左侧的值的 1 号位置必须是 1。
也就是如果 $i$ 号位置是 1，如果想要保证能够走到相邻的点，那么这个相邻的点的 $(i+4)$ 的位置一定就是 1。
根据这个性质我们对所有的格点维护一些并查集，遍历每一个点，如果能够走到相邻的点就进行合并，否则就不进行合并。最后只需要查看 $(0,0)$ 和 $(n-1,m-1)$这两个格点是否在同一个并查集里面即可(维护并查集进行合并的时候需要把二维坐标的位置转化为一维的数值，注意此时范围是 90000，不是 900)。注意这个题目的数据范围。

class Solution {
public:
    static constexpr int maxn = 90010;
    int f[maxn], net[4][2] = {{-1, 0},{0, 1},{1, 0},{0, -1}};
    int dir[7] = {0, 0b1010, 0b0101, 0b1100, 0b0110, 0b1001, 0b0011};
    //这里填数时从低位到高位,代码中是从低位开始判断的
    int Find (int v) {
        return f[v] == v? v : f[v] = Find(f[v]);
    }
    bool hasValidPath(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        for (int i = 0; i < maxn; ++ i) f[i] = i;
        auto Merge = [&] (int u, int v) {
            int t1 = Find(u), t2 = Find(v);
            if (t1 != t2) f[t1] = t2;
        };
        auto getId = [&] (int x, int y) {
            return x * m + y;
        };
        auto check = [&] (int x, int y) {
            int now = dir[grid[x][y]];//当前格点对应的方向
            for (int i = 0; i < 4; ++ i) {
                if (now & (1 << i)) {//当前方向为 1, 要保证相邻格点的位置也是 1
                    int netx = x + net[i][0];
                    int nety = y + net[i][1];
                    if (netx < 0 || netx >= n || nety < 0 || nety >= m) continue;
                    if (dir[grid[netx][nety]] & (1 << ((i + 2) % 4))) 
                    	Merge(getId(x, y), getId(netx, nety));
                }
            }
        };
        for (int i = 0; i < n; ++ i) {
            for (int j = 0; j < m; ++ j) {
                check(i, j);
            }
        }
        return Find(getId(0, 0)) == Find(getId(n - 1, m - 1));
    }
    /*vector<vector<int> > grid(2, (vector<int>(3, 0)));
    grid[0][0] = 2; grid[0][1] = 6; grid[0][2] = 3;
    grid[1][0] = 6; grid[1][1] = 5; grid[1][2] = 2;
    hasValidPath(grid);*/
};

1392. 最长快乐前缀(next 数组)

  思路：用到了字符串匹配的 next 数组代表的含义。

class Solution {
public:
    int net[100000];
    void getNext(int t,string b){
        net[0] = -1;
        for(int i = 0, j = -1; i < t; ){
            if(j == -1 || b[i] == b[j]){
                i++; j++;
                net[i] = j;
            }else j = net[j];
        }
    }
    string longestPrefix(string s) {
        int n = s.length();
        getNext(n, s);
        int len = net[n];
        string ans = "";
        for (int i = 0; i < len; ++ i) ans += s[i];
        return ans;
    }
};