ARTS 训练第一周leetcode:数组

从排序数组中删除重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。
示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。
说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

class Solution {
public:
int removeDuplicates(vector& nums){

for(vector<int>::iterator it = nums.begin()+1; it < nums.end(); ++it)
{
    if(*it == *(it-1))
    {
        nums.erase(it);
        it--;
    }
}
return nums.size();
}

};

买卖股票的最佳时机 II
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
class Solution {
public:
int maxProfit(vector& prices) {
int sum = 0;
for(vector::iterator it = prices.begin()+1; it < prices.end(); ++it)
{
if((*it - *(it-1)) > 0)
sum += *it - *(it-1);
}
return sum;
}
};

旋转数组
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:

输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的原地算法。
class Solution {
public:
void rotate(vector& nums, int k) {
if(nums.empty() || (k %= nums.size()) == 0)
return;
int n = nums.size();
reverse(nums.begin(), nums.begin()+n-k);
reverse(nums.begin()+n-k, nums.end());
reverse(nums.begin(), nums.end());
}
};

存在重复
给定一个整数数组，判断是否存在重复元素。

如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

示例 1:

输入: [1,2,3,1]
输出: true
示例 2:

输入: [1,2,3,4]
输出: false
示例 3:

输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
bool cal(int a, int b) {
return (a<b);
}
class Solution {
public:

bool containsDuplicate(vector<int>& nums) {
    if(nums.empty())
        return false;
    sort(nums.begin(),nums.end(),cal);
    vector<int>::iterator it = nums.begin()+1;
    while(*it != *(it-1) && it != nums.end())
        it++;
    if(it == nums.end())
        return false;
    return true;
}

};

只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

bool sortD(int a, int b)
{
return (a>b);
}
class Solution {
public:
int singleNumber(vector& nums) {
if(nums.empty())
return 0;
if(nums.size() == 1)
return nums[0];
sort(nums.begin(), nums.end(), sortD);

    int tmp = nums[0];
    for(vector<int>::iterator it = nums.begin()+1; it < nums.end()-1; ++it)
    {
        if(*it != *(it-1) && *it != *(it+1))
            return *it;
    }
    if(nums[0] != nums[1])
        return nums[0];
    return *(nums.end()-1);
}

};

两个数组的交集 II
给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:

如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

bool sordD(int a, int b)
{
return (a<b);
}
class Solution {
public:
vector intersect(vector& nums1, vector& nums2) {
vector set;
if(nums1.empty() || nums2.empty())
return set;

    sort(nums1.begin(), nums1.end(), sordD);
    sort(nums2.begin(), nums2.end(), sordD);
    
    vector<int>::iterator it1 = nums1.begin();
    vector<int>::iterator it2 = nums2.begin();

    while(it1 != nums1.end() && it2 != nums2.end())
    {
        if(*it1 < *it2)
        {
            it1++;
            continue;
        }
        else if(*it1 > *it2)
        {
            it2++;
            continue;
        }
        set.push_back(*it1);
        it1++;
        it2++;
    }
    return set;
    
}

};

加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
class Solution {
public:
vector plusOne(vector& digits) {
reverse(digits.begin(), digits.end());
vector::iterator it = digits.begin();
(*it)++;
while(*it > 9)
{
if((it+1) == digits.end())
{
*it -= 10;
digits.push_back(1);
}
else
{
*it -= 10;
*(it+1) += 1;
it++;
}
}
reverse(digits.begin(), digits.end());
return digits;

}

};

移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:

必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

class Solution {
public:
void moveZeroes(vector& nums) {
int count = 0;

    for(int i = 0; i < nums.size(); ++i)
    {
        int j = i;
        while((j-1) >= 0 && nums[j-1] == 0)
        {
            int tmp;
            tmp = nums[j];
            nums[j] = nums[j-1];
            nums[j-1] = tmp;
            j--;
        }
    }
}

};

两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
class Solution {
public:
vector twoSum(vector& nums, int target) {
std::unordered_map<int,int> hash;

    for (int i = 0; i < nums.size(); i++) {
        auto iter = hash.find(target - nums[i]);

        if (iter != hash.end()) {
            return vector{iter->second, i};
        };
        hash[nums[i]] = i;
    }
    return vector<int>();
}

};
判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

上图是一个部分填充的有效的数独。

数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

示例 1:

输入:
[
[“5”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”]
]
输出: true
示例 2:

输入:
[
[“8”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”]
]
输出: false
解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
说明:

一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 ‘.’ 。
给定数独永远是 9x9 形式的。

class Solution {
public:
bool isValidSudoku(vector<vector>& board) {
vector<vector> row(9, vector(9, false));
vector<vector> line(9, vector(9, false));
vector<vector> cell(9, vector(9, false));

    for(int i = 0; i < 9; ++i)
    {
        for(int j = 0; j < 9; ++j)
        {
            if(board[i][j] != '.')
            {
                int num = board[i][j] - '1';
                if(row[i][num] || line[num][j] || cell[3*(i/3) + j/3][num])
                    return false;
                row[i][num] = true;
                line[num][j] = true;
                cell[3*(i/3) + j/3][num] = true;
            }
        }
    }
    return true;
}

};

旋转图像
给定一个 n × n 的二维矩阵表示一个图像。

将图像顺时针旋转 90 度。

说明：

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例 1:

给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],

原地旋转输入矩阵，使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]
示例 2:

给定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],

原地旋转输入矩阵，使其变为:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]

// 先沿对角线转换一次，然后上下转换一次
class Solution {
public:
void rotate(vector<vector>& matrix) {
for(int i = 0; i < matrix.size(); ++i)
{
for(int j = 0; j < matrix.size()-i; ++j)
{
int tmp = matrix[i][j];
matrix[i][j] = matrix[matrix.size()-j-1][matrix.size()-i-1];
matrix[matrix.size()-j-1][matrix.size()-i-1] = tmp;
}
}
for(int i = 0; i < matrix.size()/2; ++i)
{
for(int j = 0; j < matrix.size(); ++j)
{
int tmp = matrix[i][j];
matrix[i][j] = matrix[matrix.size()-i-1][j];
matrix[matrix.size()-i-1][j] = tmp;
}
}
}
};