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