LintCode天梯(USGiants)-Integer Array

喵，小喵爬天梯系列～美国大公司。

第二弹:整数数组。

1、Remove Element

题意：
给定一个数组和一个值，在原地删除与值相同的数字，返回新数组的长度。
元素的顺序可以改变，并且对新的数组不会有影响。
分析：
小喵的第一想法，竟然题目中用的是vector，直接用用迭代器删除就好了，虽然代码简单易写，但是时间复杂度去可能达到o(n^2)。
那么我们能不能在o(n)时间解决问题呢？题目要求删除数组中的指定的元素的值x，小喵开始从另一个角度分析问题，就是保留不是指定值x的所有数据，此时就出现的转机，小喵从k=0，i=0开始扫描，如果不是A[i]！=x就直接替换A[k++] = A[i],这句话对于是x的直接直接覆盖，相等与直接删除。
图例解释：

Code1：

int removeElement(vector<int> &A, int elem) {
        // write your code here
        int n = A.size();
        int k = 0;
        vector<int>::iterator it;
        for (it = A.begin(); it != A.end(); ) {
            if (elem == (*it)) {
                ++k;
                A.erase(it);
            }
            else ++it;
        }
        return n - k;
    }

Code2:

 int removeElement(vector<int> &A, int elem) {
        // write your code here
        int n = A.size();
        int k = 0;
        for (int i=0;i<n;i++) {
            if (elem != A[i]) {
                A[k++] = A[i]; 
            }
        }
        return k;
    }

小喵总结：对于这类简单的题，每一个人都会直接有思路解决，这是我们需要思考一下，是否存在更好的算法，使得时间和空间更少。瞄～

2、Subarray Sum

题意：
给定一个整数数组，找到和为零的子数组。你的代码应该返回满足要求的子数组的起始位置和结束位置。
分析：
记录1~i的和sum[i]，进行两层循环的遍历，直接得出答案，时间复杂度o(n^2)。能否o(n)时间解决，假设子数组i+1 ~ j的和为0，则有sum[j] - sum[i] = 0；等式变形sum[i] == sum[j]，我们可以使用hash表记录，hash[sum[i] ] = i；当到达sum[j]时，hash[sum[j]] = i；则子数组的下标是[i+1, j]。

Code:

class Solution {
public:
    /**
     * @param nums: A list of integers
     * @return: A list of integers includes the index of the first number 
     *          and the index of the last number
     * 返回子数组的和是0的下标的开始和结束（任意一个）。
     */
    //if(sum[i] - sum[j] ==0 ) 存在
    //sum[j] == sum[i]
    //记录hash[sum[j]] = j
    //if 有hash[sum[i]]存在就返回[hash[sum[i]]+1,,i]
    vector<int> subarraySum(vector<int> nums){
        vector<int> res;    
        map<int,int> hash;

        hash[0] = -1;
        int sum = 0;
        for(int i=0;i<nums.size();i++){
            sum=sum+nums[i];
            if(hash.find(sum) != hash.end()){//存在这个值
                res.push_back(hash[sum]+1);
                res.push_back(i);
                break;
            }
            hash[sum] = i;
        }
        return res;
    }
};

小喵总结：还是等式的变换+哈希思想~

3、 Remove Duplicates from Sorted Array

题意：
给定一个排序数组，在原数组中删除重复出现的数字，使得每个元素只出现一次，并且返回新的数组的长度。
不要使用额外的数组空间，必须在原地没有额外空间的条件下完成。

分析：
不要使用额外的数组空间？需要在原数组上进行考虑，充分挖掘所有的有用的信息，对于排序的数组，我们得到nums[i] == nums[i-1]。原数组上删除，看一下第一个题的双指针法？用两个指针i，j，如果nums[i] != nums[i-1]，出现的新的值，就有nums[j] = nums[i];

Code:

class Solution {
public:
    /**
     * @param A: a list of integers
     * @return : return an integer
     */
    int removeDuplicates(vector<int> &nums) {
        // write your code here
        if(nums.size()==0) return 0;
        int i,j;
        i=j=1;
        for(i=1;i<nums.size();i++){
            if(nums[i]!=nums[i-1]){
                nums[j++]=nums[i];
            }
        }
        return j;

    }
};

小喵总结：双指针法和哈希思想。

4、Merge Sorted Array

题意：
合并两个排序的整数数组A和B变成一个新的数组。
你可以假设A具有足够的空间（A数组的大小大于或等于m+n）去添加B中的元素。
分析:
A有足够的空间，意味着我们不用开辟新的数组，使用归并的过程添加到将B数组的指，添加打A数组中即可，从后往前添加，因为我们要在空位置进行赋值很安全，避免覆盖A数组中的原来的值，从大到小进行归并即可。
Code：

class Solution {
public:
    /**
     * @param A: sorted integer array A which has m elements, 
     *           but size of A is m+n
     * @param B: sorted integer array B which has n elements
     * @return: void
     */
    void mergeSortedArray(int A[], int m, int B[], int n) {
        // write your code here
        int k=m+n-1;
        m--; n--;
        while(m>=0&&n>=0){
            if(A[m]>=B[n]){
                A[k--]=A[m--];
            }
            else A[k--]=B[n--];
        }
        while(n>=0){
            A[k--]=B[n--];
        }
    }
};

小喵总结：如果面试过程中，没有明确提示你A的空间很大，你会向面试官询问吗？

5、Two Sum

题意：
给一个整数数组，找到两个数使得他们的和等于一个给定的数 target。
你需要实现的函数twoSum需要返回这两个数的下标, 并且第一个下标小于第二个下标。注意这里下标的范围是 1 到 n，不是以 0 开头。

分析：
最简的方法可以直接用两层循环进行判断nums[i] + nums[j] == target,返回[i,j]。如何降低时间复杂度，一般都是空间换时间，空间？因此想到hash表，分析nums[i] + nums[j] == target；变形得到，nums[j] == target - nums[i]; (这个变形思想在编程中很重要)。出现了等式，对于
nums[i],我们纪录hash[target - nums[i]] = i; 当便利到hash[ nums[j] ] 存在时，一定是hash[nums[j]] = i; 此时有nums[i] + nums[j] == target；返回[hash[nums[j]]+1, j+1]。

Code：

class Solution {
public:
    /*
     * @param numbers : An array of Integer
     * @param target : target = numbers[index1] + numbers[index2]
     * @return : [index1+1, index2+1] (index1 < index2)
     * 使用hash纪录上一个值
     */
    vector<int> twoSum(vector<int> &nums, int target) {
        // write your code here
        map<int, int> hash;
        vector<int> res;
        for(int i = 0;i < nums.size();i ++){
            if(hash.find(nums[i]) != hash.end()){//已经存在targe-x = nums[i]
                res.push_back(hash[nums[i]] + 1);
                res.push_back(i + 1);
                break;
            }
            hash[target - nums[i]] = i;
        }
        return res;
    }
};

小喵总结：等式的变形很重要。瞄～

6、 Product of Array Exclude Itself

题意：
给定一个整数数组A。定义B[i] = A[0] * … * A[i-1] * A[i+1] * … * A[n-1]， 计算B的时候请不要使用除法。
分析：
如果可以用除法，就很简单，纪录pro = phi _[1-n] A[i] (1-n所有元素的乘积)。B[i] = pro / A[i]。为什么不能用除法？因为计算机计算时，除法相对乘法慢很多，因此避免惩罚。（面试时就碰到的这个题），那只能用乘法，对于B[i] = A[0] * … * A[i-1] * A[i-1] * A[i+1] * … * A[n-1]。我们很容易想到遍历所有的i =[0,..n-1]，先计算前一半[0 - i-1]的乘机，再计算后一半[i+1 - n-1]的乘机。注意到，前一半和后一半乘积都是连续的，我们可以提前存下来sum[i]作为0-i的乘积。sum1[i]纪录n-1 - i的乘积。此时B[i] = sum[i-1] * sum1[i+1];特殊处理一下开头和结束即可。复杂度O(n)+O(n)。

Code：

class Solution {
public:
    /**
     * @param A: Given an integers array A
     * @return: A long long array B and B[i]= A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1]
     */
    vector<long long> productExcludeItself(vector<int> &nums) {
        // write your code here
        vector<long long> A(nums.size(),1),B(nums.size(),1),res(nums.size(),1);
        if(nums.size() == 1) return res;
        A[0] = nums[0];
        for(int i=1;i<nums.size();i++){
            A[i] = A[i-1] * nums[i];
        }
        B[nums.size()-1] = nums[nums.size() - 1];
        for(int j=nums.size()-2;j>=0;j--){
            B[j] = B[j+1] * nums[j];
        }
        for(int i=0;i<nums.size();i++){
            if(i==0){
                res[i] = B[i+1];
            }
            else if(i == nums.size()-1){
                res[i] = A[i-1];
            }
            else res[i] = A[i-1] * B[i+1];
        }
        return res;
    }
};

7、First Missing Positive

题意：
给出一个无序的正数数组，找出其中没有出现的最小正整数。
例如：
如果给出 [1,2,0], return 3
如果给出 [3,4,-1,1], return 2

分析：
很容易想到进行排序之后便利。能否继续降低时间复杂度？我们排序的时候即使对n个数全部考虑，其实我们只需考虑1-n之间的数字即可。
例如数组的长度是n，对于数字i（1<= i <=n）。如果存在，那么在一个排序的数组中，它一定在第i-1个位置。因此，我们遍历所有的数，例如A[i]，如果 1 <= A[i] <=n。它的位置一定在下标A[i] - 1处。因此我们只需交换到它所在的位置，完成排序，之后遍历一下，如果发现A[i-1] != i。i就是第一个丢失的正整数。

Code：

class Solution {
public:
    /**    
     * @param A: a vector of integers
     * @return: an integer
     */
    int firstMissingPositive(vector<int> A) {
        // write your code here
        int len = A.size();
        /**
         * 我们不用管其他的值，只需要计算1-n之间的值是否在自己应该在位置即可
         * 因此我们可以将任意一个1-n直接的值放到它应该在的位置即可。
         * 之后遍历一遍，遇到第一个不在其位置的值就是丢失的值。
         */
        for(int i=0;i<len;i++){
            while(A[i]>0&&A[i]<=len&&A[A[i]-1]!=A[i]){//第i-1个位置的数不是i,注意while
                swap(A[i],A[A[i]-1]);
            }
        }
        for(int i=0;i<len;i++){
            if(A[i]!=i+1) return i+1;
        }
        return len+1;
    }
};

8、3Sum Closest

题意:
给一个包含 n 个整数的数组 S, 找到和与给定整数 target 最接近的三元组，返回这三个数的和。
分析：
如果是要求两个数的和最接近目标的值target，可以排序+二分，对于三个数，我们可以排序，然后固定一个值i, 从j = i + 1, r = n-1，进行二分得到结果。时间复杂度从直接暴力的O(n^3)降级到O(n^2)。

Code:

class Solution {
public:    
    /**
     * @param numbers: Give an array numbers of n integer
     * @param target: An integer
     * @return: return the sum of the three integers, the sum closest target.
     * 固定一个值，另外的两个指针进行二分
     */
    int threeSumClosest(vector<int> nums, int target) {
        // write your code here
        sort(nums.begin(),nums.end());
        int ans = nums[0] + nums[1] + nums[2]; 

        for(int i=0;i<nums.size();i++){
            int l = i+1,r = nums.size() - 1;
            while(l < r){
                int sum = nums[i] + nums[l] + nums[r];

                if(abs(sum - target) < abs(ans - target))   ans = sum;

                if(sum < target) l ++;
                else r--;

            }
        }

        return ans;
    }
};

9、3Sum

题意：
给出一个有n个整数的数组S，在S中找到三个整数a, b, c，找到所有使得a + b + c = 0的三元组。

分析：
此题和上一题是一样的题，只是把target=0，要求得到所有的组合，这里我们需要注意的是，不要出现同样的组合。例如[-3,1,1,2]，我们第一个选择-3，之后二分1+2-3=0。但是接下来还是1和2，又会出现1+2-3=0，因此我们排序后遇到连续相同的值，需要仅仅处理所有相同值的最后一个即可。

Code:

class Solution {
public:    
    /**
     * @param numbers : Give an array numbers of n integer
     * @return : Find all unique triplets in the array which gives the sum of zero.
     */
    vector<vector<int> > threeSum(vector<int> &nums) {
        // write your code here
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<vector<int> > result;
        for(int i=0;i<n-2;i++){
            if(i!=0 && nums[i] == nums[i-1]) continue; //防止出现相同的组合

            int l=i+1,r=n-1;
            int sum = - nums[i];
            while(l<r){
                if(nums[l] + nums[r] == sum){
                    vector<int> tmp;
                    tmp.push_back(nums[i]);
                    tmp.push_back(nums[l]);
                    tmp.push_back(nums[r]);

                    result.push_back(tmp);
                    l++;
                    r--;
                    //防止出现相同的值
                    while(nums[l-1] == nums[l]) l++;
                    while(nums[r+1] == nums[r]) r--;
                }
                else if(nums[l] + nums[r] < sum) l++;
                else r--;
            }
        }
        return result;
    }
};

小喵总结：你能不能第一时间想到这些细节问题？

10、Partition Array

题意：
给出一个整数数组 nums 和一个整数 k。划分数组（即移动数组 nums 中的元素），使得：
所有小于k的元素移到左边
所有大于等于k的元素移到右边
返回数组划分的位置，即数组中第一个位置 i，满足 nums[i] 大于等于 k。

分析：
这个题，大家应该都能搞定，就是快排的一次划分。

Code：

class Solution {
public:
    int partitionArray(vector<int> &nums, int k) {
        // write your code here

        if(nums.size() == 0) return 0;

        int i=0,j=nums.size()-1;
        while(1){
            //i<=j 注意这一句
            while(i<=j && nums[i]<k) ++i;
            while(i<=j && nums[j]>=k) --j;
            if(i>j) break;
            else{
                swap(nums[j],nums[i]);
                --j; ++i;
            }

        }
        return i;
    }
};