[Leetcode] Sum 系列

Sum 系列题解

Two Sum题解

题目来源：https://leetcode.com/problems/two-sum/description/

Description

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Solution

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target) {
    int* result = (int*)malloc(2 * sizeof(int));

    int i, j;
    for (i = 0; i < numsSize; i++) {
        for (j = 0; j < numsSize; j++) {
            if (i == j) continue;
            if (nums[i] + nums[j] == target) {
                if (i < j) {
                    result[0] = i;
                    result[1] = j;
                } else {
                    result[0] = j;
                    result[1] = i;
                }
                return result;
            }
        }
    }
    return result;
}

解题描述

这道题目还是比较简单的，为了找到目标数字的下标，使用的是直接用双层循环遍历数组里面任意两个数的和，检查和是否等于给定的target。之后再返回存有所求的两个数字的下标的数组。

更优解法

2018.1.24 更新：

之前这道题的做法属于暴力破解，时间复杂度还是较高的，达到了O(n^2)，查了一些资料之后发现使用哈希可以把时间复杂度降到O(n)：


class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hash;
        int size = nums.size();
        vector<int> res(2);
        for (int i = 0; i < size; i++) {
            auto got = hash.find(target - nums[i]);
            if (got != hash.end()) {
                res[0] = got -> second;
                res[1] = i;
                return res;
            }
            hash[nums[i]] = i;
        }
    }
};

3Sum 题解

题目来源：https://leetcode.com/problems/3sum/description/

Description

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note: The solution set must not contain duplicate triplets.

Example

For example, given array S = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

Solution

class Solution {
private:
    vector<vector<int> > twoSum(vector<int>& nums, int end, int target) {
        vector<vector<int> > res;
        int low = 0;
        int high = end;
        while (low < high) {
            if (nums[low] + nums[high] == target) {
                vector<int> sum(2);
                sum[0] = nums[low++];
                sum[1] = nums[high--];
                res.push_back(sum);

                // 去重
                while (low < high && nums[low] == nums[low - 1])
                    low++;
                while (low < high && nums[high] == nums[high + 1])
                    high--;
            } else if (nums[low] + nums[high] > target) {
                high--;
            } else {
                low++;
            }
        }
        return res;
    }
public:
    vector<vector<int> > threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        int size = nums.size();
        if (size < 3)
            return res;
        sort(nums.begin(), nums.end());
        for (int i = size - 1; i >= 2; i--) {
            if (i < size - 1 && nums[i] == nums[i + 1])  // 去重
                continue;
            auto sum2 = twoSum(nums, i - 1, 0 - nums[i]);
            if (!sum2.empty()) {
                for (auto& sum : sum2) {
                    sum.push_back(nums[i]);
                    res.push_back(sum);
                }
            }
        }
        return res;
    }
};

解题描述

这道题是Two Sum的进阶，解法上采用的是先求Two Sum再根据求到的sum再求三个数和为0的第三个数，不过题意要求不一样，Two Sum要求返回数组下标，这道题要求返回具体的数组元素。而如果使用与Two Sum相同的哈希法去做会比较麻烦。

这里求符合要求的2数之和用的方法是，先将数组排序之后再进行夹逼的办法。并且为了去重，需要在2sum和3sum都进行去重。这样2sum夹逼时间复杂度为O(n)，总的时间复杂度为O(n^2)。

4Sum 题解

题目来源：https://leetcode.com/problems/4sum/description/

Description

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note: The solution set must not contain duplicate quadruplets.

Example

For example, given array S = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

Solution

class Solution {
private:
    vector<vector<int> > twoSum(vector<int>& nums, int end, int target) {
        vector<vector<int> > res;
        int low = 0;
        int high = end;
        while (low < high) {
            if (nums[low] + nums[high] == target) {
                vector<int> sum(2);
                sum[0] = nums[low++];
                sum[1] = nums[high--];
                res.push_back(sum);

                // 去重
                while (low < high && nums[low] == nums[low - 1])
                    low++;
                while (low < high && nums[high] == nums[high + 1])
                    high--;
            } else if (nums[low] + nums[high] > target) {
                high--;
            } else {
                low++;
            }
        }
        return res;
    }

    vector<vector<int> > threeSum(vector<int>& nums, int end, int target) {
        vector<vector<int>> res;
        if (end < 2)
            return res;
        sort(nums.begin(), nums.end());
        for (int i = end; i >= 2; i--) {
            if (i < end && nums[i] == nums[i + 1])  // 去重
                continue;
            auto sum2 = twoSum(nums, i - 1, target - nums[i]);
            if (!sum2.empty()) {
                for (auto& sum : sum2) {
                    sum.push_back(nums[i]);
                    res.push_back(sum);
                }
            }
        }
        return res;
    }
public:
    vector<vector<int> > fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        int size = nums.size();
        if (size < 4)
            return res;
        sort(nums.begin(), nums.end());
        for (int i = size - 1; i >= 2; i--) {
            if (i < size - 1 && nums[i] == nums[i + 1])  // 去重
                continue;
            auto sum3 = threeSum(nums, i - 1, target - nums[i]);
            if (!sum3.empty()) {
                for (auto& sum : sum3) {
                    sum.push_back(nums[i]);
                    res.push_back(sum);
                }
            }
        }
        return res;
    }
};

解题描述

这道题可以说是3Sum的再次进阶，使用的方法和3Sum基本相同，只是在求3个数之和之后再套上一层循环。时间复杂度为O(n^3)。

3Sum Closest 题解

题目来源：https://leetcode.com/problems/3sum-closest/description/

Description

Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

Example

    For example, given array S = {-1 2 1 -4}, and target = 1.

    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

Solution

class Solution {
private:
    inline int abInt(int val) {
        return val >= 0 ? val : -val;
    }
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int size = nums.size();
        if (size < 3)
            return 0;
        sort(nums.begin(), nums.end());
        int closest = nums[0] + nums[1] + nums[2];
        int first, second, third, sum;
        for (first = 0; first < size - 2; ++first) {
            if (first > 0 && nums[first] == nums[first - 1])
                continue; // 去重
            second = first + 1;
            third = size - 1;
            while (second < third) {
                sum = nums[first] + nums[second] + nums[third];
                if (sum == target)
                    return sum;
                if (abInt(sum - target) < abInt(closest - target))
                    closest = sum;
                if (sum < target)
                    ++second;
                else
                    --third;
            }
        }
        return closest;
    }
};

解题描述

这道题可以说是3Sum的变形，题意上是要求在数组里面找到三个数的和最接近target，也就是说可能不等于target。算法上面与3Sum的解法有一定的相似度，先固定一个位置first，在其后进行夹逼求最接近target的三数之和。

原文地址：https://www.cnblogs.com/yanhewu/p/8482751.html

时间： 2024-11-08 22:36:07

[Leetcode] Sum 系列的相关文章

Leetcode算法系列（链表）之两数相加

Leetcode算法系列(链表)之两数相加 难度:中等给出两个 非空 的链表用来表示两个非负的整数.其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字.如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和.您可以假设除了数字 0 之外,这两个数都不会以 0 开头.示例:输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)输出:7 -> 0 -> 8原因:342 + 465 = 807 链接:https://le

Leetcode permutation 系列

关于permutation的讲解,请参见http://blog.csdn.net/xuqingict/article/details/24840183 下列题目的讲解均是基于上面的文章: 题1: Next Permutation Total Accepted: 8066 Total Submissions: 32493My Submissions Implement next permutation, which rearranges numbers into the lexicographic

[leetcode]Sum Root to Leaf Numbers @ Python

原题地址:http://oj.leetcode.com/problems/sum-root-to-leaf-numbers/ 题意: Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number. An example is the root-to-leaf path 1->2->3 which represents the number 123. Fin

【Leetcode长征系列】Letter Combinations of a Phone Number

原题: Given a digit string, return all possible letter combinations that the number could represent. A mapping of digit to letters (just like on the telephone buttons) is given below. Input:Digit string "23" Output: ["ad", "ae"

【Leetcode长征系列】Merge k Sorted Lists

原题: Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 思路:两条两条地合并.时间复杂度为O(n),n为所有链表节点和. 代码: /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) :

LeetCode: Sum Root to Leaf Numbers [129]

[题目] Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number. An example is the root-to-leaf path 1->2->3 which represents the number 123. Find the total sum of all root-to-leaf numbers. For example, 1 /

LeetCode——Sum Root to Leaf Numbers

Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number. An example is the root-to-leaf path 1->2->3 which represents the number 123. Find the total sum of all root-to-leaf numbers. For example, 1 / 2 3 T

［LeetCode蠕动系列］Sort List

这题前一阵子就看到了,一直没时间做,昨晚睡前想了想,要求n*log(n)以内的时间复杂度,第一时间想到的就是归并.快排和希尔排序(注:希尔排序时间为O(n^1.3),在数据量大于2的情况下小于n*log(n)),个人以为,链表的特性更适合归并,所以采用归并排序,实现的merge代码如下: public static ListNode merge(ListNode rhead, ListNode lhead) { ListNode head = null; if (rhead.val <= lhe

【Leetcode长征系列】Construct Binary Tree from Inorder and Postorder Traversal

原题: Given inorder and postorder traversal of a tree, construct the binary tree. Note: You may assume that duplicates do not exist in the tree. 思路:和上一题一样,后续我们可以通过最后一个值得到根的值,同样可以通过定位根的值得到左右子树的子集,递归求解即可. 代码: /** * Definition for binary tree * struct Tre