LeetCode 第 207 场周赛

A 重新排列单词间的空格

写了个比较暴力的做法，代码不优美。

class Solution {
public:
    string reorderSpaces(string text) {
        int c1 = 0;
        int l = -1, r = -1;
        vector<string> ans;
        for (int i = 0; i < text.size(); i++) {
            if (text[i] == ' ') {
                if (l != -1) {
                    string s = text.substr(l, r - l + 1);
                    ans.push_back(s);
                }     
                l = -1;
                c1++;
            }
            else {
                if (l == -1) l = i;
                r = i;
            }
        }
        if (l != -1) {
            ans.push_back(text.substr(l, r - l + 1));
        }
        string res = "";
        if (ans.size() == 1) {
            res = ans[0];
            for (int i = 1; i <= c1; i++) res = res + " ";
            return res; 
        }
        int p = c1 / (ans.size() - 1);
        for (int i = 0; i < ans.size(); i++) {
            res = res + ans[i];
            if (i != ans.size() - 1) {
                for (int j = 1; j <= p; j++) res = res + " ";
            }
        }
        int cpp = (c1 % (ans.size() - 1));
        for (int i = 1; i <= cpp; i++) res = res + " ";
        return res;
    }
};

B 拆分字符串使唯一子字符串的数目最大

DFS暴力跑，到每个位置枚举所有能够的长度

class Solution {
public:
    set<string> se;
    int ans = 0;
    int Max(int a, int b) {
        return a > b ? a : b;
    }
    void dfs(string s, int pos) {
        
        for (int i = 1; i <= s.size() - pos; i++) {
            string str = s.substr(pos, i);
            if (se.find(str) == se.end()) {
                se.insert(str);
                ans= Max(ans, se.size());
                dfs(s, pos + i);
                se.erase(str);
            }
        }

    }
    int maxUniqueSplit(string s) {
        dfs(s, 0);
        return ans;
    }
};

C 矩阵的最大非负积

class Solution {
public:
    const long long mod = 1000000007;
    int n, m;
    long long ans = -1;
    bool vis[20][20];
    long long Max(long long a, long long b) {
        return a > b ? a : b;
    }
    void dfs(int x, int y, vector<vector<int>>& g, long long val) {
        if (val == 0) {
            ans = Max(ans, 0);
            return ;
        }
        if (x == n - 1 && y == m - 1) {
            ans =Max(ans, val);
        }
        if (x + 1 < n) {
            dfs(x + 1, y, g, (val * g[x + 1][y]));
        }
        if (y + 1 < m) {
            dfs(x, y + 1, g, (val * g[x][y + 1]));
        }
    }
    int maxProductPath(vector<vector<int>>& grid) {
        n = grid.size();
        m = grid[0].size();
        dfs(0, 0, grid, grid[0][0]);
        return (int) (ans % mod);
    }
};

D 连通两组点的最小成本

状压DP，不会做了，待补。