LeetCode 随机刷题1

1053. 交换一次的先前排列

难度：中等。
这个题好奇怪啊，刚开始没看懂，看了题解。感觉这个题没什么意义。

正确解法：

class Solution {
public:
    vector<int> prevPermOpt1(vector<int>& arr) {
        int n = arr.size();
        int a = n;
        for(int i = n - 1; i > 0; i--){
            if(arr[i] < arr[i - 1]){
                a = i - 1;
                break;
            }
        }
        if(a == n)return arr;

        int b = a + 1;
        for(int i = a + 2; i < n; i++){
            if(arr[i] > arr[b] && arr[i] < arr[a])b = i;
        }
        swap(arr[a], arr[b]);
        return arr;
    }
};

结果：

1000. 合并石头的最低成本

考试要是遇到这种题，我就直接跪下。
看题解都看不太懂。最后也是抄了答案。遇见就放弃。

class Solution {
public:
    int mergeStones(vector<int>& stones, int k) {
        int n = stones.size();
        if((n - 1) % (k - 1) != 0)return - 1;
        vector<vector<vector<int>>> dp(n + 1);
        for(int i = 0; i <= n; i++){
            dp[i].resize(n + 1);
            for(int j = 0; j <= n; j++){
                dp[i][j].resize(k + 1);
            }
        }

        vector<int> sum(n + 1);
        for(int i = 1; i <= n; i++)sum[i] = sum[i - 1] + stones[i - 1];

        for(int step = 2; step <= n; step++){
            for(int i = 1; i <= n - step + 1; i++){
                int j = i + step - 1;
                for(int m = 2; m <= k; m++){
                    dp[i][j][m] = dp[i][i][1] + dp[i + 1][j][m - 1];
                    for(int p = i + k - 1; p < j; p+= k - 1){
                        dp[i][j][m] = min(dp[i][j][m], dp[i][p][1] + dp[p + 1][j][m - 1]);
                    }
                }
                dp[i][j][1] = dp[i][j][k] + sum[j] - sum[i - 1];
            }
        }
        return dp[1][n][1];
    }
};

结果：

886. 可能的二分法

难度：中等。
标签：深度优先搜索，图。

这个题压根没想到是图，可能之前真的没有做过图的问题吧。

class Solution {

    bool dfs(vector<vector<int>>& graph, vector<int>& group, int i){
        for(int j = 0; j < graph[i].size(); j++){
            if(graph[i][j]){
                if(group[i] == group[j])return false;
                if(group[j] == 0){
                    group[j] = -group[i];
                    if(!dfs(graph, group, j))return false;
                }
            }
        }
        return true;
    }

public:
    bool possibleBipartition(int N, vector<vector<int>>& dislikes) {

        vector<vector<int>> graph(N + 1, vector<int>(N + 1));
        for(int i = 0; i < dislikes.size(); i++){
            graph[dislikes[i][0]][dislikes[i][1]] = 1;
            graph[dislikes[i][1]][dislikes[i][0]] = 1;
        }

        vector<int> group(N + 1);
        for(int i = 1; i <= N; i++){
            if(group[i] == 0){
                group[i] = 1;
                if(!dfs(graph, group, i))return false;
            }
        }
        return true;
    }
};

结果：

脑子不好了，下次再做吧