⭐算法入门⭐《二分枚举》简单03 —— LeetCode 1. 两数之和

🙉饭不食，水不饮，题必须刷🙉
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
LeetCode 太难？先看简单题！ 🧡《C语言入门100例》🧡
数据结构难？不存在的！ 🌳《画解数据结构》🌳
闭关刷 LeetCode，剑指大厂Offer！ 🌌《LeetCode 刷题指引》🌌
LeetCode 太简单？算法学起来！ 💜《夜深人静写算法》💜

一、题目

1、题目描述

  给定一个整数数组 $nums$ 和一个整数目标值 $target$，请在该数组中找出 和为目标值 $target$ 的那 两个 整数，并返回它们的数组下标。假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
  样例输入： $numbers=[1,5,11,19]$, $target=6$
  样例输出： $[0,1]$

2、基础框架

• c++ 版本给出的基础框架代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    }
};

• 输入数组参数类型是vector<int>，返回参数也是一个数组vector<int>，按照题目要求，需要返回一个长度为 2 的数组；
  

3、原题链接

LeetCode 1. 两数之和

二、解题报告

1、思路分析

  首先，我们可以对数组进行排序，然后枚举一个数，二分枚举另一个数。从而找到一个可行解。但是问题在于，要求输出的是下标，排序以后下标就乱了。
  所以可以引入一个结构体，结构体存储的是 值 和 下标两个值，并且实现一个仿函数，对值进行排序。然后再进行枚举和二分枚举，如果找到了可行解，就将结构体的成员变量中的下标塞到结果数组中即可。

2、时间复杂度

• 排序的时间复杂度为 $O(nlo{g}_{2}n)$。
• 第一层枚举 $O(n)$，第二层二分查找 $O(lo{g}_{2}n)$，两个操作是乘的关系，所以总的时间复杂度为 $O(nlo{g}_{2}n)$。

3、代码详解

class Solution {
    class Point {                                       // (1)
        int val, idx;
    public:
        Point(){}
        Point(int _v, int _i): val(_v), idx(_i) {}
        int getval() const {
            return val;
        }
        int getidx() const {
            return idx;
        }
        bool operator < (const Point& o) const {
            return val < o.val;
        }
    };

public:
    int find(vector<Point>& numbers, int indexStart, int target) {  // (2)
        int l = indexStart;
        int r = numbers.size() - 1;
        while(l <= r) {
            int mid = (l + r) >> 1;
            if(target == numbers[mid].getval()) {
                return mid;
            }else if(target > numbers[mid].getval()) {
                l = mid + 1;
            }else {
                r = mid - 1;
            }
        }
        return -1;
    }
    vector<int> twoSum(vector<int>& nums, int target) {
        vector <int> ans;
        vector< Point > pts;
        for(int i = 0; i < nums.size(); ++i) {
            pts.push_back( Point(nums[i], i) );
        }
        sort(pts.begin(), pts.end());                               // (3)

        for(int i = 0; i < pts.size(); ++i) {                       // (4)
            int idx = find(pts, i+1, target - pts[i].getval());
            if(idx != -1) {                                         // (5)
                ans.push_back(pts[i].getidx());
                ans.push_back(pts[idx].getidx());
                return ans;
            }
        }
        return ans;
    }
};

• $(1)$ Point是一个结构体，这个结构体存储的是给定数组的值和下标；
• $(2)$ int find(vector<Point>& numbers, int indexStart, int target)实现的是二分查找函数，查找的是从数组numbers的indexStart下标开始到结尾中存在的target所在的下标，不存在则返回 -1；
• $(3)$ 组织原本的整型数组的数据到结构体数组中；
• $(4)$ 枚举数组numbers的每个位置i，期望找到numbers[i] + numbers[x] = target，其中 $x$ 是未知数，需要我们求的，并且它满足 $x>i$，由于数组有序，就可以用二分查找了，二分查找的值就是target - numbers[i]；
• $(5)$ 得到的 $x$ 如果不为 -1，那么 $i$ 和 $x$ 就是两个满足题意的目标；
• 关于二分查找的内容，可以参考这个题：【算法入门】二分枚举（简单 - 第一题）LeetCode 704

---

三、本题小知识

用结构体来保存下标和值，然后再进行按值排序，就能够将原本的下标给还原出来。

---