leetcode 数组类型题

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <vector>
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>

using namespace std;
void show(const vector<int>& nums){
    for (int i = 0; i < nums.size(); i++){
        cout << '	' << nums[i];
    }
    cout << endl;
}

int removeDuplicate(vector<int>& nums){
    if (nums.empty()) return 0;
    int index = 1;
    for (int i = 1; i < nums.size(); i++){
        if (nums[i - 1] != nums[i])
            nums[index++] = nums[i];
    }
    return index;
}

vector<int> twoSum(vector<int>& nums, int target){
    unordered_map<int, int> mapping;
    vector<int> res;
    for (int i = 0; i < nums.size(); i++)
        mapping[nums[i]] = i;
    for (int i = 0; i < nums.size(); i++){
        int gap = target - nums[i];
        if (mapping.find(gap) != mapping.end()){
            res.push_back(i + 1);
            res.push_back(mapping.find(gap)->second + 1);
            break;
        }
    }
    return res;
}

vector<vector<int>> threeSum(vector<int>& nums){
    vector<vector<int>> result;
    const int target = 0;
    if (nums.size() < 3) return result;
    sort(nums.begin(), nums.end());
    auto last = nums.end();
    for (auto i = nums.begin(); i < last - 2; ++i){
        while (i>nums.begin() && *i == *(i - 1)) continue;
        auto j = i + 1;
        auto k = last - 1;
        while (j < k){
            if (*i + *j + *k < target) {
                ++j;
                while (*j == *(j - 1) && j < k) ++j;
            }
            else if (*i + *j + *k > target){
                --k;
                while (*k == *(k + 1) && j < k) --k;
            }
            else{
                result.push_back({ *i, *j, *k });
                ++j;
                --k;
                while (*j == *(j - 1) && *k == *(k + 1) && j < k) ++j;
            }
        }
    }
    return result;
}

int threeSumClose(vector<int>& nums, int target){
    int result = 0;
    int min_gap = INT_MAX;
    sort(nums.begin(), nums.end());
    auto last = nums.end();
    for (auto i = nums.begin(); i < last - 2; ++i){
        auto k = last - 1;
        auto j = i + 1;
        while (j < k){
            int sum = *i + *j + *k;
            int gap = abs(sum - target);
            if (gap < min_gap){
                min_gap = gap;
                result = sum;
            }
            if (sum < target) ++j;
            else --k;
        }
    }
    return result;
}

void next_Permutation(vector<int>& nums){
    int i, j, k = nums.size();
    for (i = k - 2; i >= 0; i--){
        if (nums[i] < nums[i + 1]){
            for (j = k - 1; j > i; j--){
                if (nums[j] > nums[i])
                    break;
            }
            swap(nums[i], nums[j]);
            reverse(nums.begin() + i + 1, nums.end());
            return;
        }
    }
    reverse(nums.begin(), nums.end());
}

int trap_Water(vector<int>& hights){
    int result = 0;
    int l = 0, r = hights.size() - 1;
    while (l < r){
        int mn = min(hights[l], hights[r]);
        if (mn == hights[l]){
            ++l;
            while (mn > hights[l] && l < r)
                result += mn - hights[l++];
        }
        else{
            --r;
            while (mn > hights[r] && l < r)
                result += mn - hights[r--];
        }
    }
    return result;
}

int trap_WaterII(vector<int>& heights) {
    vector<int> dpLeft(heights.size(), 0);
    int maxLeft = 0;
    for (int i = 0; i<heights.size(); ++i){
        dpLeft[i] = maxLeft;
        maxLeft = max(heights[i], maxLeft);
    }
    show(dpLeft);
    int maxRight = 0;
    vector<int> dpRight(heights.size(), 0);
    for (int j = heights.size() - 1; j >= 0; --j){
        dpRight[j] = maxRight;
        maxRight = max(heights[j], maxRight);
    }
    show(dpRight);
    int result = 0;
    for (int k = 0; k<heights.size(); ++k){
        int minDiff = min(dpLeft[k], dpRight[k]);
        if (minDiff > heights[k])
            result += minDiff - heights[k];
    }
    return result;
}

void rotate(vector<vector<int>>& matrix) {
    const int n = matrix.size();  //matrix 的行数
    for (int i = 0; i < n;++i)
        for (int j = 0; j < n - i; ++j)
            swap(matrix[i][j], matrix[n - 1 - i][n - 1 - j]); // 副对角线反转

    for (int i = 0; i < n / 2;++i)
        for (int j = 0; j < n; ++j)
            swap(matrix[i][j], matrix[n - 1 - i][j]);//水平中线反转
}

vector<int> plusOne(vector<int>& digits){
    int c = 1;//表示进位 carry
    for (auto it = digits.rbegin(); it != digits.rend(); ++it){
        *it += c;
        c = *it / 10;
        *it = *it % 10;
    }
    if (c > 0) digits.insert(digits.begin(), 1);
    return digits;
}

int climbStairs(int n){ //迭代
    int pre = 0;
    int cur = 1;
    for (int i = 1; i <= n; i++){
        int tmp = cur;
        cur += pre;
        pre = tmp;
    }
    return cur;
}

vector<int> grayCode(int n){
    int size = 1 << n; //2^n
    vector<int> result;
    result.reserve(size);
    for (int i = 0; i < size; ++i)
        result.push_back(i ^ (i >> 1));
    return result;
}

void setZeroes(vector<vector<int>>& matrix){
    const int rows = matrix.size();
    const int columns = matrix[0].size();
    vector<bool> rowFlag(rows, false);
    vector<bool> columnFlag(columns, false);
    for (int i = 0; i < rows; ++i){
        for (int j = 0; j < columns; ++j){
            if (matrix[i][j] == 0)
                rowFlag[i] = columnFlag[j] = true;
        }
    }
    for (int i = 0; i < rows; ++i){
        if (rowFlag[i]){
            for (int j = 0; j < columns; ++j)
                matrix[i][j] = 0;
        }
    }
    for (int i = 0; i < columns; ++i){
        if (columnFlag[i]){
            for (int j = 0; j < rows; ++j)
                matrix[j][i] = 0;
        }
    }
}

int canCompleteCircuit(vector<int>& gas, vector<int>& cost){
    int total = 0,sum = 0,start = 0;
    for (int i = 0; i < gas.size(); ++i){
        total += gas[i] - cost[i];
        sum += gas[i] - cost[i];
        if (sum < 0){
            start = i + 1;
            sum = 0;
        }
    }
    return total >= 0 ? start : -1;
}

int candy(vector<int>& ratings){
    const int n = ratings.size();
    vector<int> nums(n, 1);
    for (int i = 0; i < n-1; ++i){
        if (ratings[i] < ratings[i+1])
            nums[i+1] = nums[i] + 1;
    }
    for (int j = n - 1; j>0; --j){
        if (ratings[j] < ratings[j - 1])
            nums[j - 1] = max(nums[j - 1], nums[j] + 1);
    }
    return accumulate(nums.begin(), nums.end(),0);
}

int candyII(vector<int>& ratings) {
    if (ratings.size() == 0) return 0;
    vector<int> minLeft(ratings.size(), 1);
    for (int i = 1; i<ratings.size(); ++i){
        if (ratings[i]>ratings[i - 1])
            minLeft[i] = minLeft[i - 1] + 1;
    }
    vector<int> minRight(ratings.size(), 1);
    for (int j = ratings.size() - 2; j >= 0; --j){
        if (ratings[j]>ratings[j + 1]) //如果左边的等级高，而且左边的糖果又少的话 
            minRight[j] = max(minLeft[j], (minRight[j + 1] + 1));
    }
    int result = 0;
    for (int k = 0; k<ratings.size(); ++k)
        result += max(minLeft[k], minRight[k]);  //取从左边和右边都最小的值中的最大值，这样就满足所有条件了。 
    return result;
}

int singleNumber(vector<int>& nums){
    int x = 0;
    for (int i = 0; i < nums.size(); ++i)
        x ^= nums[i];
    return x;
}

int singleNumberII(vector<int>& nums) {
    int result = 0;
    for (int i = 0; i < 32; ++i){
        int sum = 0;
        for (int j = 0; j < nums.size(); ++j){
            sum += (nums[j] >> i) & 1;
        }
        result += (sum % 3) << i;// result |= (sum % 3) << i;
    }
    return result;
}



int main()
{
    int myints[] = { 0,1,1,0,2,0,1};
    vector<int> myvec(myints, myints + sizeof(myints) / sizeof(int));
    cout << "result:" << singleNumberII(myvec) << endl;
    system("pause");
    return 0;
}

题目参考教材：https://github.com/soulmachine/leetcode（leetcode-cpp.pdf）