剑指offer

/数组中出现次数超过一半的数字:
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
投票法：初始cnt = 0, val = -1;
若cnt == 0， 则将val设为当前值，cnt=1；
往后遍历，若与val相等，则cnt++,否则cnt–/

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int cnt = 0, val = -1;
        for (auto x:nums) {
            if (cnt == 0) {
                val = x;
                cnt = 1;
            } else {
                if (val == x) {
                    cnt += 1;                    
                } else {
                    cnt -= 1;
                }
            }
        }
        return val;
    }
};

/连续子数组的最大和:
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
要求时间复杂度为O(n)。/

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        vector<int> dp(n, 0);
        dp[0] = nums[0];
        int res = dp[0];
        for (int i = 1; i < n; i++) {
            dp[i] = max(0, dp[i-1]) + nums[i];
            if (dp[i] > res) {
                res = dp[i];
            }
        }
        return res;
    }
};

/*给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。
一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。
*/

class Solution {
public:
    int translateNum(int num) {
        string src = to_string(num);
        int size = src.size();
        vector<int> dp(size+1);
        dp[0] = 1;
        dp[1] = 1;
        for(int i = 2; i <= size; i++) {
            dp[i] = dp[i-1];
            int tmp = (src[i-2] - '0') * 10 + (src[i-1] - '0');
            if (tmp >= 10 && tmp <= 25) {
                dp[i] += dp[i-2];
            }
        }
        return dp[size];
    }
};

/礼物的最大价值:
在一个 mn 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。
给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？
动态规划：*/

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {
        if (grid.size() == 0 || grid[0].size() == 0) {
            return 0;
        }
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        dp[0][0] = grid[0][0];
        for (int i = 1; i < m; i++) {
            dp[i][0] = grid[i][0] + dp[i-1][0];
        }
        for (int j = 1; j < n; j++) {
            dp[0][j] = grid[0][j] + dp[0][j-1];
        }
        for (int i = 2; i < m; i++) {
            for (int j = 2; j < n; j++) {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
};

/请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。
滑动窗口：/

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int cnt = s.size();
        if (cnt == 0) {
            return 0;
        }
        int l = 0, r= -1;
        int mp[256] = {0};
        int res = 0;
        while (l < cnt) {
            if (r+1 < cnt && mp[s[r+1]] == 0) {
                mp[s[++r]]++;
                if (res < r-l+1) {
                    res = r-l+1;
                }
            } else {
                mp[s[l++]]--;
            }
        }
        return res;
    }
};

/丑数：
我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。
思路：/

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> ans(n);
        int i2 = 0, i3 = 0, i5 = 0;
        ans[0] = 1;
        for (int i = 1; i < n; i++) {
            ans[i] = min(ans[i2]*2, min(ans[i3]*3, ans[i5]*5));
            if (ans[i] == ans[i2]*2) {
                i2++;
            }
            if (ans[i] == ans[i3]*3) {
                i3++;
            }
            if (ans[i] == ans[i5]*5) {
                i5++;
            }
        }
        return ans[n-1];
    }
};

/第一个只出现一次的字符
在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。/

class Solution {
public:
    char firstUniqChar(string s) {
        map<char, int> mp;
        for (int i = 0; i < s.size(); i++) {
            mp[s[i]]++;
        }
        for (int i = 0; i < s.size(); i++) {
            if (mp[s[i]] == 1) {
                return s[i];
            }
        }
        return ' ';
    }
};

/数组中的逆序对:在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
思路：mergesort边排序边计算/

class Solution {
    int res;
    void merge(vector<int>& nums, vector<int>& tmp, int l, int mid, int r) {
        int i = l, j = mid+1, k = 0;
        while (i <= mid && j <= r) {
            if (nums[i] > nums[j]) {
                tmp[k++] = nums[j++];
                res += (mid+1-i);
            } else {
                tmp[k++] = nums[i++];
            }
        }
        while (i <= mid) {
            tmp[k++] = nums[i++];
        }
        while (j <= r) {
            tmp[k++] = nums[j++];            
        }
        for (i = 0; i < r-l+1; i++) {
            nums[i+l] = tmp[i];
        }
    }
    void mergeSort(vector<int>& nums, vector<int>& tmp, int l, int r) {
        if (l < r) {
            int mid = l + (r-l)/2;
            mergeSort(nums, tmp, l, mid);
            mergeSort(nums, tmp, mid+1, r);
            merge(nums, tmp, l, mid, r);
        }
    }
public:
    int reversePairs(vector<int>& nums) {
        res = 0;    
        vector<int> tmp(nums.size());
        mergeSort(nums, tmp, 0, nums.size()-1);
        return res;
    }
};

/在排序数组中查找数字 I:统计一个数字在排序数组中出现的次数。/

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int len = nums.size();
        if (len == 0) {
            return 0;
        }
        int ll = 0, rr = len - 1, mid = 0;
        while (ll <= rr) {
            mid = ll + ((rr - ll) >> 1);
            if (nums[mid] == target) {
                int i = mid, j = mid;
                while (i>0 && nums[i-1] == nums[mid]) {
                    i--;
                }
                while (j + 1 < nums.size() && nums[j+1] == nums[mid]) {
                    j++;
                }
                return j-i+1;
            } else if (nums[mid] > target) {
                rr = mid - 1;
            } else {
                ll = mid + 1;
            }
        }
        return 0;
    }
};

/0～n-1中缺失的数字:
一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。/

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int l = 0;
        int r = nums.size() - 1;
        while(l <= r) {
            int mid = l + (r-l)/2;
            if (nums[mid] == mid) {
                l = mid+1;
            } else {
                r = mid-1;                
            }
        }
        return l;
    }
};

/二叉搜索树的第k大节点/

class Solution {
    int _k;
    int res;
    void dfs(TreeNode* root, int k) {
        if (!root) {
            return;
        }
        dfs(root->right, k);
        _k--;
        if (_k == 0) {
            res = root->val;
            return;
        }
        dfs(root->left, k);
    }
public:
    int kthLargest(TreeNode* root, int k) {
        _k = k;
        res = 0;
        dfs(root, k);
        return res;

    }
};

/二叉树的深度/

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (!root) {
            return 0;
        }
        int leftmax = maxDepth(root->left);
        int rightmax = maxDepth(root->right);
        return max(leftmax, rightmax) + 1;
    }
};

/平衡二叉树/

class Solution {
    int getDepth(TreeNode* root) {
        if (!root) {
            return 0;
        }
        int leftmax = getDepth(root->left);
        int rightmax = getDepth(root->right);
        return max(leftmax, rightmax) + 1;
    }
public:
    bool isBalanced(TreeNode* root) {
        if (!root) {
            return true;
        }
        int leftdep = getDepth(root->left);
        int rightdep = getDepth(root->right);
        if ((abs(leftdep - rightdep) <= 1) && isBalanced(root->left) && isBalanced(root->right)) {
            return true;
        } else {
            return false;
        }
    }
};

/数组中数字出现的次数:
一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。/

class Solution {
public:
    vector<int> singleNumbers(vector<int>& nums) {
        vector<int> res;
        int ans = 0; //a^b
        for (auto num:nums) {
            ans ^= num;
        }
        int bitMask = 1;// 找出a和b不同的第一位
        while((ans & bitMask) == 0) {
            bitMask <<= 1;
        }
        int a = 0;
        int b = 0;
        for (auto num:nums) {
            if (bitMask & num) {
                a ^= num;
            } else {
                b ^= num;
            }
        }
        res.push_back(a);
        res.push_back(b);
    }
};

/在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。/

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        if (nums.empty()) {
            return 0;
        }
        // 存储所有数字二进制表示的每一位的和
        int bitNum[32] = {0};
        int res = 0;
        for (auto x:nums) {
            unsigned int bitMask = 1;
            // 对数字的32位进行累加，从低位开始
            for (int i = 31; i >= 0; i--) {
                // 计算该位是1还是0
                if ((x & bitMask) != 0) {
                    bitNum[i]++;
                }
                // 将掩码的1左移，接着计算右起开始的下一位
                bitMask = bitMask << 1;
            }
        }
        for (auto b:bitNum) {
            // 考虑到最后一位的情况，
            // 应该先左移再计算
            res <<= 1;
            res += (b % 3);
        }
        return res;
    }
};