Leetcode 周赛150

1. 拼写单词
   题意：给n个单词，和一串字母表，表中每个单词只能用一次，但个数不限，求字母表能匹配的单词个数，输出匹配单词长度和
   思路：暴力匹配

class Solution {
public:
    int countCharacters(vector<string>& words, string chars) {
        int cnt[30];
        memset(cnt, 0, sizeof(cnt));
        int ans = 0;
        for (int i = 0; i < chars.length(); i++)
            cnt[chars[i]-'a']++;
        for (int i = 0; i < words.size(); i++) {
            int flag = 1;
            for (int j = 0; j < words[i].length(); j++) {
                cnt[words[i][j]-'a']--;
                if (cnt[words[i][j]-'a'] < 0) {
                    flag = 0;
                }
            }
            if (flag) {
                ans += words[i].length();
            } 
            for (int j = 0; j < words[i].length(); j++)
                cnt[words[i][j]-'a']++;
        }
        return ans;
    }
};

2. 最大层内元素和
   题意：给一棵二叉树，求出每层节点和最大的层，若有多个答案，输出最小的层数
   思路：简单BFS

class Solution {
public:
    int maxLevelSum(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int maxx = -1e9, cnt = 1, ans = 0;
        while (!q.empty()) {
            int len = q.size(), sum = 0;
            for (int i = 0; i < len; i++) {
                TreeNode* node = q.front(); q.pop();
                if (node->left != NULL)
                    q.push(node->left);
                if (node->right != NULL)
                    q.push(node->right);
                sum += node->val;
            }
            if (sum > maxx) {
                maxx = sum;
                ans = cnt;
            }
            cnt++;
        }
        return ans;
    }
};

3. 地图分析
   题意：给一个n*n的矩阵，每个点1表示陆地，0表示海洋，求出距离陆地最远的海洋离与其最近的陆地的距离，这里距离表示曼哈顿距离，即|x0 - x1| + |y0 - y1|
   思路：曼哈顿距离即两点之间最少走多少步能相互到达。明白这点就知道可以用搜索，以陆地为源点，用bfs求出所有陆地到所有海洋的最短距离中最大的那个输出

struct node {
	int x, y;
	node(int x = 0, int y = 0) : x(x), y(y) {}
};
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
class Solution {
public:
    int maxDistance(vector<vector<int>>& grid) {
        int n = grid.size();
        queue<node> q;
        int dp[n+1][n+1];
        memset(dp, -1, sizeof(dp));
        int ans = -1;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                if (grid[i][j]) {
                    q.push(node(i, j));
                    dp[i][j] = 0;
                }
        while (!q.empty()) {
            node t = q.front(); q.pop();
            for (int i = 0; i < 4; i++) {
                int x = t.x+dx[i], y = t.y+dy[i];
                if (x >= 0 && y >= 0 && x < n && y < n && dp[x][y] == -1 && !grid[x][y]) {
                    dp[x][y] = dp[t.x][t.y]+1;
                    q.push(node(x, y));
                //	printf("dp[%d][%d]:%d\n", x, y, dp[x][y]);
                    ans = max(ans, dp[x][y]);
                }
            }
        }
        return ans;
    }
};

最后一题求字符串中字典序最大的连续子串，有些用Python直接暴力枚举子串就过了，其他语言的大部分用后缀数组，有个用STL的最好理解，先利用max_element()找出最大元素，再枚举找最大元素开头的字典序最大的子序列

class Solution {
public:
    string lastSubstring(string s) {
        int ans = -1; 
        char c = *max_element(s.begin(), s.end());     
        for (int i = 0; i < s.size(); i++) {
            if (c == s[i]) {
                if (ans == -1) ans = i;
                else {
                    if (memcmp(s.c_str()+ans, s.c_str()+i, s.size()-i) < 0) 
                        ans = i;
                }
            }
        }
        return s.substr(ans);
    }
};