wy的leetcode刷题记录_Day71

wy的leetcode刷题记录_Day71

声明

本文章的所有题目信息都来源于leetcode
如有侵权请联系我删掉!
时间：2024-1-3（补）

前言

2487. 从链表中移除节点

今天的每日一题是：2487. 从链表中移除节点

题目介绍

给你一个链表的头节点 head 。

移除每个右侧有一个更大数值的节点。

返回修改后链表的头节点 head 。

示例 1：
> 输入：head = [5,2,13,3,8]
输出：[13,8]
解释：需要移除的节点是 5 ，2 和 3 。> - 节点 13 在节点 5 右侧。

• 节点 13 在节点 2 右侧。
• 节点 8 在节点 3 右侧。

示例 2：
输入：head = [1,1,1,1]
输出：[1,1,1,1]
解释：每个节点的值都是 1 ，所以没有需要移除的节点。

思路

方法一：暴力解：通过两重嵌套循环来寻找新链表，具体如下：1.每一轮循环寻找当前链表的最大值将最大值加入新链表2.每一轮循环从上一次循环寻找到的加入新链表的节点开始遍历。（超时，时间复杂度n的2次方）
方法二：换个思路：本题其实应该在考察寻找出链表中的右往左找非递减序列 可以从序列尾部开始遍历，俩种做法递归或者模拟栈。
方法三：延续方法二的思路，这次我们不使用栈而是直接将链表反转来进行操作最后将符合条件的条件在进行一次反转即可。
部分思路参考作者：力扣官方题解

代码

方法一：暴力

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNodes(ListNode* head) {
        int maxVal=0;
        ListNode* maxValPointer=nullptr;
        ListNode* newHeader=nullptr;
        ListNode* temp=nullptr;
        int count=0;
        while(head)
        {
            count++;
            maxVal=0;
            maxValPointer=nullptr;
            while(head)
            {
                if(head->val>maxVal)
                {
                    maxVal=head->val;
                    maxValPointer=head;
                }
                head=head->next;
            }

            head=maxValPointer->next;//下一次遍历从新节点开始

            if(count==1)//如果是头节点则创建新链表
            {
                newHeader=maxValPointer;
                temp=newHeader;
                newHeader->next=nullptr;
            }
            else//如果是尾节点则加入新链表
            {
                temp->next=maxValPointer;
                temp=temp->next;
                temp->next=nullptr;
            }
        }

        return newHeader;


    }
};

方法二：递归

class Solution {
public:
    ListNode* removeNodes(ListNode* head) {
        if (head == nullptr) {
            return nullptr;
        }
        head->next = removeNodes(head->next);
        if (head->next != nullptr && head->val < head->next->val) {
            return head->next;
        } else {
            return head;
        }
    }
};

模拟栈

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNodes(ListNode* head) {
        //换个思路：本题其实应该在考察寻找出链表中的右往左找非递减序列 可以从序列尾部开始遍历
        stack<ListNode* > stk;
        for(;head!=nullptr;head=head->next)
        {
            stk.push(head);
        }
        while(!stk.empty())
        {
            if(head==nullptr||stk.top()->val>=head->val)
            {
                stk.top()->next=head;
                head=stk.top();
            }
            stk.pop();

        }
        return head;
    }
};

方法三：反转链表：

class Solution {
public:
    ListNode *reverse(ListNode *head) {
        ListNode dummy;
        while (head != nullptr) {
            ListNode *p = head;
            head = head->next;
            p->next = dummy.next;
            dummy.next = p;
        }
        return dummy.next;
    }

    ListNode* removeNodes(ListNode* head) {
        head = reverse(head);
        for (ListNode *p = head; p->next != nullptr; ) {
            if (p->val > p->next->val) {
                p->next = p->next->next;
            } else {
                p = p->next;
            }
        }
        return reverse(head);
    }
};

收获

通过暴力模拟提高了解题的速度，手速题秒杀！后续的对时间复杂度的改进是通过对题目的深度解读，发现了另一种思路，转换思路之后得出了一种更为简洁的解法以及时间优化度更高的方法，通过模拟栈和递归俩种写法加深的对函数调用的理解。

509. 斐波那契数

动态规划基础篇之——509. 斐波那契数

题目介绍

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

思路

同之前的爬楼梯那一题十分相似都可以采用对应的递归方法或者递推方法以及矩阵快速幂…

代码

递归：

class Solution {
public:
    int fib(int n) {
        if(n==0||n==1)
            return n;
        return fib(n-1)+fib(n-2);
    }
};

递推:

class Solution {
public:
    int fib(int n) {
        int a=0;
        int b=1;
        int c=a+b;
        for(int i=2;i<=n;i++)
        {
            c=a+b;
            a=b;
            b=c;
        }
        return c;
    }
};

矩阵快速幂：

class Solution {
public:
            //矩阵乘法
    vector<vector<int>> martix_mutiply(vector<vector<int>> &a,vector<vector<int>>& b)
    {
        vector<vector<int>> c{{0,0},{0,0}};
        for(int i=0;i<2;i++)
        {
            for(int j=0;j<2;j++)
            {
                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
            }
        }
        return c;
    }
    //快速幂
    vector<vector<int>> martix_rapid_pow(vector<vector<int>> &a,int n)
    {
        vector<vector<int>> ret{{1,0},{0,1}};
        while(n>0)
        {
            if(n&1)
            {
                ret=martix_mutiply(ret,a);
            }
            n>>=1;
            a=martix_mutiply(a,a);
        }
        return ret;
    }

    int fib(int n) {
        //矩阵快速幂
        if (n < 2) {
            return n;
        }
        vector<vector<int>> q{{1, 1}, {1, 0}};
        vector<vector<int>> res = martix_rapid_pow(q, n - 1);
        return res[0][0];


    }

};

收获

巩固矩阵快速幂！