存档

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;
}
};