lintcode 中等题:4 Sum 四个数之和

题目

四数之和

给一个包含n个数的整数数组S,在S中找到所有使得和为给定整数target的四元组(a, b, c, d)。

样例

例如,对于给定的整数数组S=[1, 0, -1, 0, -2, 2] 和 target=0. 满足要求的四元组集合为:

(-1, 0, 0, 1)

(-2, -1, 1, 2)

(-2, 0, 0, 2)

注意

四元组(a, b, c, d)中,需要满足a <= b <= c <= d

答案中不可以包含重复的四元组。

解题

怎么感觉下面程序已经没法修改了但是在39%测试数据时候超时

public class Solution {
    /**
     * @param numbers : Give an array numbersbers of n integer
     * @param target : you need to find four elements that‘s sum of target
     * @return : Find all unique quadruplets in the array which gives the sum of
     *           zero.
     */
    public ArrayList<ArrayList<Integer>> fourSum(int[] numbers, int target) {
        //write your code here
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(numbers == null || numbers.length < 4)
            return result;
        Arrays.sort(numbers);
        for(int i=0;i< numbers.length - 1 ; i++){
            if(numbers[i]==numbers[i+1])
                continue;
            for(int j = numbers.length - 1;j>i ;j--){
                if(numbers[j] == numbers[j-1])
                    continue;
                int left = i + 1;
                int right = j - 1;
                int n = target - numbers[i] - numbers[j];
                while(left< right){
                    while(numbers[left] == numbers[++left] && left<right);
                     left--;
                     while(numbers[right] == numbers[--right] && left<right);
                     right++;

                    int sum = numbers[left] + numbers[right];
                    if(n==sum){
                        ArrayList<Integer> path = new ArrayList<Integer>();
                        path.add(numbers[i]);
                        path.add(numbers[left]);
                        path.add(numbers[right]);
                        path.add(numbers[j]);
                        if(!result.contains(path))
                            result.add(path);
                    }
                    else if(sum<target){
                        left++;
                    }else{
                        right--;
                    }
                }// end while
            }// end for
        }// end for
        return result;
    }
}

Java Code

九章上面的代码,感觉和上面的明明差不多,但是就能通过

public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
        ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
        Arrays.sort(num);

        for (int i = 0; i < num.length - 3; i++) {
            if (i != 0 && num[i] == num[i - 1]) {
                continue;
            }

            for (int j = i + 1; j < num.length - 2; j++) {
                if (j != i + 1 && num[j] == num[j - 1])
                    continue;

                int left = j + 1;
                int right = num.length - 1;
                while (left < right) {
                    int sum = num[i] + num[j] + num[left] + num[right];
                    if (sum < target) {
                        left++;
                    } else if (sum > target) {
                        right--;
                    } else {
                        ArrayList<Integer> tmp = new ArrayList<Integer>();
                        tmp.add(num[i]);
                        tmp.add(num[j]);
                        tmp.add(num[left]);
                        tmp.add(num[right]);
                        rst.add(tmp);
                        left++;
                        right--;
                        while (left < right && num[left] == num[left - 1]) {
                            left++;
                        }
                        while (left < right && num[right] == num[right + 1]) {
                            right--;
                        }
                    }
                }
            }
        }

        return rst;
    }
}

Java Code

在对比两个程序发现,确实有错误,最重要的还是,在sum==target 的时候left和right 没有变化,其他的小错误是在参考网上程序时候没有改完

改成下面的程序但是还是在78% 的测试数据时候有错误。

public class Solution {
    /**
     * @param numbers : Give an array numbersbers of n integer
     * @param target : you need to find four elements that‘s sum of target
     * @return : Find all unique quadruplets in the array which gives the sum of
     *           zero.
     */
    public ArrayList<ArrayList<Integer>> fourSum(int[] numbers, int target) {
        //write your code here
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(numbers == null || numbers.length < 4)
            return result;
        Arrays.sort(numbers);
        for(int i=0;i< numbers.length - 4 ; i++){
            for(int j = numbers.length - 1;j>i ;j--){
                int left = i + 1;
                int right = j - 1;
                while(left< right){

                    int sum = numbers[i] + numbers[j] + numbers[left] + numbers[right];
                    if(target==sum){
                        ArrayList<Integer> path = new ArrayList<Integer>();
                        path.add(numbers[i]);
                        path.add(numbers[left]);
                        path.add(numbers[right]);
                        path.add(numbers[j]);
                        if(!result.contains(path))
                            result.add(path);
                        left++;
                        right--;
                    }
                    else if(sum<target){
                        left++;
                    }else{
                        right--;
                    }
                }// end while
            }// end for
        }// end for
        return result;
    }
}

Java Code

在网上看到别人程序对第一四个数据进行去重,感觉这个是有问题的,比如:-1 -1 1 1, -1 -1 -1 3  这个也是个答案的,但是上面九章给的程序确实是由去重的操作。。。。

仔细看九章的程序,发现:

1,i是第一个数,j是第二个数,Start是第三个数,End是第四个数

2.,前两个数进行了去重,对计算过的Start和End也进行了去重,start和End去重很好理解,但是对于前两个数去重我就不能理解了

3.上面78%报错的程序修改成九章的,在39%处报错,去除前两个去重的程序,还是在78%出报错,但是我发现在target==92的时候我的程序输出的结果有75个值和正确答案是一样的。至于为什么我还是不明白,四个数的顺序应该是没有影响的,如果不去重只是多运行几次,但是不至于报错的。。。。但是这里还是有了影响。

时间: 2024-10-13 17:27:33

lintcode 中等题:4 Sum 四个数之和的相关文章

lintcode 中等题:sort letters by case字符大小写排序

题目 字符大小写排序 给定一个只包含字母的字符串,按照先小写字母后大写字母的顺序进行排序. 您在真实的面试中是否遇到过这个题? Yes 样例 给出"abAcD",一个可能的答案为"acbAD" 注意 小写字母或者大写字母他们之间不一定要保持在原始字符串中的相对位置. 挑战 在原地扫描一遍完成 解题 这个题目很简单,前面刚做一个把大于某个数之和的排在后面,快速排序的思想 public class Solution { /** *@param chars: The le

18 4Sum((寻找四个数之和为指定数的集合Medium))

题目意思:给一个乱序数组,在里面寻找三个数之和为target的所有情况,这些情况不能重复,增序排列 思路:采用3Sum的做法 ps:有见一种用hash的,存任意两个元素的和,然后变成3sum问题,需要判断重复 图书馆的网,已经到了令人发指的程度,我告诫自己千万不要暴躁. 1 class Solution { 2 public: 3 vector<vector<int>> fourSum(vector<int>& nums, int target) { 4 vec

lintcode 中等题: 3 Sum II 三数之和II

题目 三数之和 II 给一个包含n个整数的数组S, 找到和与给定整数target最接近的三元组,返回这三个数的和. 样例 例如S = [-1, 2, 1, -4] and target = 1.  和最接近1的三元组是 -1 + 2 + 1 = 2. 注意 只需要返回三元组之和,无需返回三元组本身 解题 和上一题差不多,程序也只是稍微修改了 public class Solution { /** * @param numbers: Give an array numbers of n integ

lintcode 中等题:continuous subarray sum 联系子数组之和

题目 连续子数组求和 给定一个整数数组,请找出一个连续子数组,使得该子数组的和最大.输出答案时,请分别返回第一个数字和最后一个数字的值.(如果两个相同的答案,请返回其中任意一个) 样例 给定 [-3, 1, 3, -3, 4], 返回[1,4]. 解题 法一:直接暴力,时间复杂度O(N2),时间超时 public class Solution { /** * @param A an integer array * @return A list of integers includes the i

lintcode 中等题:2 Sum 两个数的和

题目 两数之和 给一个整数数组,找到两个数使得他们的和等于一个给定的数target. 你需要实现的函数twoSum需要返回这两个数的下标, 并且第一个下标小于第二个下标.注意这里下标的范围是1到n,不是以0开头. 样例numbers=[2, 7, 11, 15], target=9 return [1, 2] 注意你可以假设只有一组答案. 解题 题目之前做LeetCode时候写过这个,利用这里利用ArrayList,当 target- numbers[i] 不在 list中,把numbers[i

lintcode 中等题:Divide Two Integers 两个数的除法

题目 两个整数相除 将两个整数相除,要求不使用乘法.除法和 mod 运算符. 如果溢出,返回 2147483647 . 样例 给定被除数 = 100 ,除数 = 9,返回 11 解题  15%的通过率,减法,位运算?表示不知道如何下手. 法一:利用减法,超时,人工直接去除的一些情况太流氓. public class Solution { /** * @param dividend the dividend * @param divisor the divisor * @return the re

lintcode 中等题:maximum subarray最大子数组II

题目 最大子数组 II 给定一个整数数组,找出两个不重叠子数组使得它们的和最大. 每个子数组的数字在数组中的位置应该是连续的. 返回最大的和. 您在真实的面试中是否遇到过这个题? Yes 样例 给出数组[1, 3, -1, 2, -1, 2],这两个子数组分别为[1, 3]和[2, -1, 2]或者[1, 3, -1, 2]和[2],它们的最大和都是7 注意 子数组最少包含一个数 挑战 要求时间复杂度为O(n) 解题 最大子数组I 这个题目是求一个数组中一个最大子数组的和,而本题目是求数组中的前

lintcode 中等题:maximum subarray difference 最大子数组差

题目 最大子数组差 给定一个整数数组,找出两个不重叠的子数组A和B,使两个子数组和的差的绝对值|SUM(A) - SUM(B)|最大. 返回这个最大的差值. 样例 给出数组[1, 2, -3, 1],返回 6 注意 子数组最少包含一个数 挑战 时间复杂度为O(n),空间复杂度为O(n) 解题 刚做了数组中两个子数组和的最大值,这一题是求差,感觉上题的求解思想应该是可以用的 A B 分别是两个子数组的和,则: 所以 当A>B 的时候A越大越好 B越小越好 当A<B 的时候B越大越好 A越小越好

lintcode 中等题:next permutation下一个排列

题目 下一个排列 给定一个整数数组来表示排列,找出其之后的一个排列. 样例 给出排列[1,3,2,3],其下一个排列是[1,3,3,2] 给出排列[4,3,2,1],其下一个排列是[1,2,3,4] 注意 排列中可能包含重复的整数 解题 和上一题求上一个排列应该很类似 1.对这个数,先从右到左找到递增序列的前一个位置,peakInd 2.若peakInd = -1 这个数直接逆序就是答案了 3.peakInd>= 0 peakInd这个位置的所,和 peakInd 到nums.size() -1