leetcode算法（一）

• （1）斐波那契數列
• （2）兩數之和

（1）斐波那契數列

• 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

   F(0) = 0,   F(1) = 1
   F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
  

• 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。答案需要取模
  1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

• 示例1：

   - 输入：n = 2 		输出：1
  

• 示例2：

    - 输入：n = 5     输出：5
  

解決方法：动态规划

• 斐波那契数的边界条件是 F(0)=0F(0)=0F(0)=0 和 F(1)=1F(1)=1F(1)=1。当 n>1n>1n>1
  时，每一项的和都等于前两项的和，因此有如下递推关系：

  F(n)=F(n−1)+F(n−2)

• 由于斐波那契数存在递推关系，因此可以使用动态规划求解。动态规划的状态转移方程即为上述递推关系，边界条件为 F(0)和F(1)。

• 根据状态转移方程和边界条件，可以得到时间复杂度和空间复杂度都是 O(n)O(n)O(n) 的实现。由于 F(n)F(n)F(n) 只和
  F(n−1)与 F(n−2）有关，因此可以使用「滚动数组思想」把空间复杂度优化成O(1)。
  

class Solution {
public:
    int fib(int n) {
        if(n<2) return n;
        int q,p=0,r=1;
        for(int i=2;i<=n;i++){
            q=p;
            p=r;
            r=(p+q)%Mod;
        }
        return r;
    }
private:
    int Mod=1000000007;
};

（2）兩數之和

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

• 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

• 你可以按任意顺序返回答案

• 示例 1：

  • 输入：nums = [2,7,11,15], target = 9
  • 输出：[0,1]
  • 解释：因为 nums[0] + nums[1] = 9 ，返回 [0, 1]

• 示例 2：

  • 输入：nums = [3,2,4], target = 6
  • 输出：[1,2]

• 示例 3：

  • 输入：nums = [3,3], target = 6
  • 输出：[0,1]

方法解決：

• 1）暴力枚举
  最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int number=0;
        vector<int>sum;
            for (int i = 0; i < nums.size(); i++)
            {
                  number=target-nums[i];
                  for (int j = i+1; j < nums.size(); j++)
                  {
                        if(number==nums[j]){
                              sum.push_back(i);
                              sum.push_back(j);
                              return sum;
                        }          
                  }
                  
            }
            return sum;
         }
};

• 2）哈希表
  注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N)降低到 O(1)。这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;
        for (int i = 0; i < nums.size(); i++) {
            auto it = hashtable.find(target - nums[i]);
            if (it != hashtable.end()) {
                return {it->second, i};
            }
            hashtable[nums[i]] = i;
        }
        return {};
      }   
      void printfTwoSum(vector<int>nums){
            for(auto&x:nums){
                  cout<<x<<endl;
            }
      }
};
int main(){
      Solution s;
      vector<int>num{2,4,7,3};

      s.printfTwoSum(s.twoSum(num,9));
      return 0;
}