C/C++教程

leetcode算法(一)斐波那契數列、兩數之和

本文主要是介绍leetcode算法(一)斐波那契數列、兩數之和,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

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;
}
这篇关于leetcode算法(一)斐波那契數列、兩數之和的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!