2021_01_23 LeetCode刷题

724. 寻找数组的中心索引

简单模拟题。先遍历一遍求取所有元素的和，之后重新遍历，遍历的过程中对于每一个元素进行求和，作为左边元素的和，右边元素的和则使用总共的和减去左边元素的和与当前的元素即可得到。遍历的时候第一个元素的下标进行特殊判定。空数组也需要特殊判定。

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        int sum = 0, length1 = nums.size();
        if(length1 == 0)
            return -1;
        for(int i = 0;i < length1; i++)
            sum += nums[i];
        int ans = -1,sum1 = 0;
        for(int i = 1; i < length1 ; i++) {
            sum1 += nums[i-1];
            if(sum1 == (sum - sum1 - nums[i])) {
                ans = i;
                break;
            }
        }
        if(0 == (sum - nums[0])) 
            ans = 0;
        return ans;
    }
};

783. 二叉搜索树节点最小距离

二叉搜索树的中序遍历性质应用。中序遍历顺序为左子树节点--根节点--右子树节点。二叉搜索树的节点满足左子树节点小于根节点，右子树节点大于根节点的性质，所以中序遍历的过程中其实就是将每个数值按照从小到大的顺序排序，那么在这个过程中对于每个相邻的进行求差，即可得到最小的差值。但是吧这个方法其实自己不太理解的了，虽然是最优解，但是还是用了另一种保险的做法，就是存储所有数值然后排序在求取差值即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDiffInBST(TreeNode* root) {
        vector<int> ans;
        dfs(root,ans);
        sort(ans.begin(),ans.end());
        int length1 = ans.size(), ans1 = ans[1] - ans[0];
        for(int i = 1;i < length1; i++)
            ans1 = min(ans1, ans[i] - ans[i-1]);
        return ans1;
    }   
    void dfs(TreeNode* root, vector<int>& p) {
        if(root == nullptr)
            return;
        p.push_back(root->val);
        dfs(root->left, p);
        dfs(root->right, p);
    }
};

819. 最常见的单词

简单模拟题。字符串题目通常就是按照题目意思进行模拟，通常实现的过程较为复杂，只要耐心一点一般就可以解决。

class Solution {
public:
    string mostCommonWord(string paragraph, vector<string>& banned) {
        map<string,int> p;
        set<string> q;
        string ans1 = "";
        int length2 = banned.size();
        for(int i = 0;i < length2; i++)
            q.insert(banned[i]);
        int length1 = paragraph.length(), max1 = -1;
        for(int i = 0;i < length1; i++) {
            if(paragraph[i] >= 'A' && paragraph[i] <= 'Z')
                paragraph[i] = char((int)paragraph[i] + 32);
        }
        for(int i = 0;i < length1; i++) {
            if(paragraph[i] >= 'a' && paragraph[i] <= 'z') {
                string ans = "";
                int j = i;
                while(paragraph[j] >= 'a' && paragraph[j] <= 'z') {
                    ans += paragraph[j];
                    j += 1;
                }
                if(q.count(ans))
                    p[ans] = 0;
                else
                    p[ans] += 1;
                max1 = max(max1, p[ans]);
                i = j;
            }
        }

        for(map<string,int>::iterator it1 = p.begin();it1 != p.end(); it1++) {
            if(it1->second == max1 && !q.count(it1->first)) {
                ans1 = it1->first;
                break;
            } 
        }
        return ans1;
    }
};

811. 子域名访问计数

简单模拟提。字符串基本处理操作，稍微有点复杂，但是按照要求实现即可。统计各个域名的出现次数通过哈希表，统计之后再将数字和域名转化成字符串进行存储即可。

class Solution {
public:
    vector<string> subdomainVisits(vector<string>& cpdomains) {
        vector<string> ans;
        map<string,int> p;
        int length1 = cpdomains.size();
        for(int i = 0; i < length1; i++) {
            int len1 = cpdomains[i].length();
            int num1 = 0;
            string temp = "";
            for(int j = 0;j < len1; j++) {
                if(cpdomains[i][j] >= '0' && cpdomains[i][j] <= '9')
                    num1 = num1 * 10 + (cpdomains[i][j] - '0');
                if(cpdomains[i][j] == ' ') {
                    temp = cpdomains[i].substr(j+1);
                    p[temp] += num1;
                    break;
                }
            }
            int len2 = temp.length();
            for(int k = 0;k < len2; k++) {
                if(temp[k] == '.') {
                    string temp1 = temp.substr(k + 1);
                    p[temp1] += num1;
                }
            }
        }
        for(map<string,int>::iterator it1 = p.begin();it1 != p.end();it1++) {
            string tempz = to_string(it1->second) + " " + it1->first;
            ans.push_back(tempz);
        }
        return ans;
    }
};