力扣hot100 91-100记录

91-100

（动态规划）

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> f(m, vector<int>(n, 1));
        for(int  i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                f[i][j] = f[i-1][j] + f[i][j-1];
            } 
        }
        return f[m-1][n-1];        
    }
};//91

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        if(m == 0) return 0;
        int n = grid[0].size();
        const int dr[2] = {1, 0};
        const int dd[2] = {0, 1};
        vector<vector<int>> f(m, vector<int>(n, INT_MAX));

        f[0][0] = grid[0][0];
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                for(int d = 0; d < 2; d++){
                    int ii = i + dr[d];
                    int jj = j + dd[d];
                    if(ii == m || jj == n) continue;
                    f[ii][jj] = min(f[ii][jj], f[i][j] + grid[ii][jj]);
                }
            }
        }
        return f[m-1][n-1];
    }
};//92

class Solution {
public:
    pair<int, int> expandAroundCenter(const string& s, int left, int right) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            --left;
            ++right;
        }
        return {left + 1, right - 1};
    }
        string longestPalindrome(string s) {
        int start = 0, end = 0;
        for (int i = 0; i < s.size(); ++i) {
            auto [left1, right1] = expandAroundCenter(s, i, i);
            auto [left2, right2] = expandAroundCenter(s, i, i + 1);
            if (right1 - left1 > end - start) {
                start = left1;
                end = right1;
            }
            if (right2 - left2 > end - start) {
                start = left2;
                end = right2;
            }
        }
        return s.substr(start, end - start + 1);
    }

    string longestPalindrome2(string s) {
        int n = s.size();
        if(n < 2) return s;
        int maxLen = 1;
        int begin = 0;
        vector<vector<int>> dp(n, vector<int>(n));
        for(int i =0; i<n; i++){
            dp[i][i] = true;
        }
        for(int L = 2; L <= n; L++){
            for(int i = 0; i < n; i++){
                int j = i + L - 1;
                if(j >= n) break;
                if(s[i] == s[j]){
                    if(j - i < 3){
                        dp[i][j] = true;
                    }else{
                        dp[i][j] = dp[i+1][j-1];
                    }
                }else{
                    dp[i][j] = false;
                }
                if(dp[i][j] && L > maxLen){
                maxLen = L;
                begin = i;
            }
          }
        }
        return s.substr(begin, maxLen);
    }
};//93

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size(), n = text2.size();
        vector<vector<int>> dp(m+1, vector<int>(n+1));
        for(int i = 1; i <= m; i++){
            char c1 = text1[i-1];
            for(int j = 1; j <= n; j++){
                char c2 = text2[j-1];
                if(c1 == c2){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return dp[m][n];
    }
};//94

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size();
        int n = word2.size();
        if(n*m == 0) return n + m;
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));

        for(int i = 0; i <= m; i++){
            dp[i][0] = i;
        }
        for(int j = 0; j <= n; j++){
            dp[0][j] = j;
        }
        for(int i = 1; i <= m; i++){
            for(int j = 1; j <= n; j++){
                int left = dp[i-1][j] + 1;
                int right = dp[i][j-1] + 1;
                int left_right = dp[i-1][j-1] + (word1[i-1] == word2[j-1] ? 0 : 1);
                dp[i][j] = min(left_right, min(left, right));
           }
        }
        return dp[m][n];
    }
};//95

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ret = 0;
        for(auto num:nums){
            ret ^= num;
        }
        return ret;
    }
};//96

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int,int> counts;
        int duo=0, cnt=0;
        for(int num:nums){
            counts[num]++;
            if(counts[num] > cnt){
                cnt = counts[num];
                duo = num;
            }
        }
        return duo;
    }
};//97

class Solution {
public:
    void sortColors2(vector<int>& nums) {
        sort(nums.begin(),nums.end());
    }
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        int ptr = 0;
        for(int i = 0; i < n; i++){
            if(nums[i] == 0){
                swap(nums[i], nums[ptr++]);
            }
        }
        for(int i = ptr; i < n; i++){
            if(nums[i] == 1){
                swap(nums[i], nums[ptr++]);
            }
        }
    }
};//98

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        next_permutation(nums.begin(), nums.end());
    }
};//99

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int n = nums.size();
        int l = 1, r = n - 1, ans = -1;
        while(l <= r){
            int mid = (r + l) >> 1;
            int cnt = 0;
            for(int num : nums){
                cnt += num <= mid;
            }            
            if(cnt <= mid){
                l = mid + 1;
            }else{
                r = mid - 1;
                ans = mid;
            }
        }
        return ans;
    }
};//100