存档

Plus One

1:

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int takeOver = 1;
        int n = digits.size();
        for(int i = n - 1; i >= 0; --i){
            digits[i] += takeOver;
            if(digits[i] > 9 && i != 0){
                digits[i] -= 10;
                takeOver = 1;
            }
            else if(digits[i] <= 9){
                return digits;
            }
            else{
                digits[i] -= 10;
                digits.insert(digits.begin(), 1);
            }
        }
        return digits;
    }
};

2:

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int n = digits.size();
        for (int i = n - 1; i >= 0; --i){
            if(digits[i] == 9){
                digits[i] = 0;
            }
            else{
                digits[i]++;
                return digits;
            }
        }
        digits[0] = 1;
        digits.push_back(0);
        return digits;
    }
};

Remove Duplicates from Sorted Array

1:

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int size = nums.size();
        if(size == 0)            
            return 0;
        int index = 0;
        for (int i = 1; i < size; ++i){
            if (nums[index] != nums[i])
                nums[++index] = nums[i];
        }
        return index + 1;
    }
};

2:

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.size() < 1)
            return nums.size();
        vector<int>::iterator iter1, iter2;
        for(iter1 = nums.begin(), iter2 = nums.begin() + 1; iter2 != nums.end();){
            if(*iter1 == *iter2)
                iter2 = nums.erase(iter2);
                else{
                    iter1++;
                    iter2++;
                }
        }
        return nums.size();
    }
};

3:

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
      int n = nums.size();
      if(n <= 1)
        return n;
      int count = 0;
      for(int i = 1; i < n; ++i){
          if(nums[i] == nums[i - 1])
            count++;
          else
            nums[i - count] = nums[i];
      }
      return n - count;
    }
};

Remove Duplicates from Sorted Array II

1:

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if(n <= 2)
            return n;
        vector<int>::iterator iter1, iter2, iter3;
        for(iter1 = nums.begin(), iter2 = iter1 + 1, iter3 = iter1 + 2; iter1 != nums.end() && iter2 != nums.end() && iter3 != nums.end();){
            if(*iter1 != *iter2){
                ++iter1;
                ++iter2;
                ++iter3;
            }
            else if(*iter1 == *iter2 && *iter2 != *iter3){
                iter1 = iter3;
                iter2 = iter1 + 1;
                iter3 = iter2 + 1;
            }
            else if(*iter1 == *iter2 && *iter2 == *iter3){
                vector<int>::iterator iter;
                for(iter = iter3; iter != nums.end(); ++iter){
                    if(*iter != *iter1){
                        break;
                    }
                }
                iter1 = nums.erase(iter3, iter);
                iter2 = iter1 + 1;
                iter3 = iter2 + 1;
            }
        }
        return nums.size();
    }
};

2:

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if(n <= 2)
            return n;
        int i = 1, j = 1;
        int count = 1;
        while(j < n){
            if(nums[j] != nums[j - 1]){
                count = 1;
                nums[i++] = nums[j];
            }
            else{
                if(count < 2){
                    nums[i++] = nums[j];
                    count++;
                }
            }
            ++j;
        }
        return i;
    }
};

Rotate Image

1:

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        for(int i = 0; i < n / 2; ++i){
            for(int j = 0; j < n; ++j){
                swap(matrix[i][j], matrix[n - 1 - i][j]);
            }
        }
        
        for(int i = 0; i < n; ++i){
            for(int j = i + 1; j < n; ++j){
                swap(matrix[i][j], matrix[j][i]);
            }
        }
    }
};

2:

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        reverse(matrix.begin(), matrix.end());
        for(int i = 0; i < matrix.size(); ++i){
            for(int j = 0; j < i; ++j){
                swap(matrix[i][j], matrix[j][i]);
            }
        }
    }
};

anticlockwise_rotate:

class Solution {
public:
    void anti_rotate(vector<vector<int>>& matrix) {
       for(auto vi : matrix) 
           reverse(vi.begin(), vi.end());
	   for(int i = 0; i < matrix.size(); ++i){
		   for(int j = 0; j < i; ++j){
		       swap(matrix[i][j], matrix[j][i]);
		   }
	   }
    }
};

Search in Rotated Sorted Array

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        int first = 0, last = n - 1;
        while(first <= last){
            int mid = (first + last) / 2;
            if(nums[mid] == target)
                return mid;
            if(nums[first] <= nums[mid]){
                if(nums[first] <= target && nums[mid] > target){
                    last = mid - 1;
                }
                else{
                    first = mid + 1;
                }
            }
            else{
                if(nums[mid] < target && target <= nums[last]){
                    first = mid + 1;
                }
                else{
                    last = mid - 1;
                }
            }
        }
        return -1;
    }
};

two sum

1:

class Solution {
public:
    vector<int> twoSum(vector<int> &nums, int target) {
        vector<int> numsCopy = nums;
        sort(numsCopy.begin(), numsCopy.end());
        int nLength = (int)numsCopy.size();
        int index1 = 0, index2 = nLength - 1;
        while(index1 < index2){
            if(numsCopy[index1] + numsCopy[index2] == target)
                break;
            else if(numsCopy[index1] + numsCopy[index2] > target)
                --index2;
            else
                ++index1;
        }
        int result1, result2;
        for(int i = 0; i < nLength; ++i){
            if(nums[i] == numsCopy[index1]){
                result1 = i + 1;
                break;
            }
        }
        for(int i = nLength - 1; i >= 0; --i){
            if(nums[i] == numsCopy[index2]){
                result2 = i + 1;
                break;
            }
        }
        if(result1 > result2){
            swap(result1, result2);
        }
        vector<int> result{result1, result2};
        return result;
    }
};

2:

class Solution {
public:
    vector<int> twoSum(vector<int> &nums, int target) {
        map<int, int> mapping;
        vector<int> result;
        for(int i = 0; i < nums.size(); ++i){
            mapping[nums[i]] = i;
        }
        for(int i = 0; i < nums.size(); ++i){
            const int gap = target - nums[i];
            if(mapping.find(gap) != mapping.end() && mapping[gap] > i){
                result.push_back(i + 1);
                result.push_back(mapping[gap] + 1);
                break;
            }
        }
        return result;
    }
};