91-100
（动态规划）
cpp
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
cpp
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
cpp
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
cpp
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
cpp
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
cpp
class Solution {
public:
int singleNumber(vector<int>& nums) {
int ret = 0;
for(auto num:nums){
ret ^= num;
}
return ret;
}
};//96
cpp
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
cpp
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
cpp
class Solution {
public:
void nextPermutation(vector<int>& nums) {
next_permutation(nums.begin(), nums.end());
}
};//99
cpp
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