leetcode-k个元素一组反转链表/股票买卖问题/接雨水

最新推荐文章于 2024-02-29 13:27:26 发布
最新推荐文章于 2024-02-29 13:27:26 发布
阅读量380 收藏
点赞数
分类专栏： leetcode 文章标签： 链表 leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40123329/article/details/89508446
版权

一 k个元素一组反转链表

前奏：反转链表

搞3个指针即可，分别指向当前处理的节点，当前处理节点的前一个节点，当前处理节点的下一个节点。

下一节点在进入循环之前已经设置了，不是空的。

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead==NULL)
            return NULL;
        ListNode *pre=NULL;
        ListNode *current=pHead;
        ListNode *_next=current->next;
        
        while(_next)
        {
            current->next=pre;
            pre=current;
            current=_next;
            _next=current->next;
        }
        current->next=pre;
        return current;
    }
};

下一节点在进入循环前设置为空，每次进入循环之后才设置为当前节点的下一节点。

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead==NULL)
            return NULL;
        ListNode *pre=NULL;
        ListNode *current=pHead;
        ListNode *_next=NULL;
        
        while(current)
        {
            _next=current->next;
            current->next=pre;
            pre=current;
            current=_next;
        }
        return pre;
    }
};

2种方法都可以，但要特别注意循环结束的条件和最后返回的指针，否则会处出现_next指向空指针的下一个节点或者返回空指针。

K个元素为一组反转链表，不够K个元素不反转

每K个元素按照反转链表的方式进行反转，然后要把这些链表链接起来即可。

1 2 3 4 5 6 7 8
以每隔3个元素反转
3 2 1 6 5 4 7 8
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k<=1||head==NULL)
            return head;
        ListNode *pre=NULL;
        ListNode *current=head;
        ListNode *_next=NULL;
        ListNode *check=head;
        
        int cnt=0;
        int cando=0;
       
        //判断够不够反转
        while(check&&cando<k)
        {
            cando++;
            check=check->next;
        }
        
        //如果个数到达K，说明可以反转
        if(cando==k)
        {
            while(cnt<k)
            {
                _next=current->next;
                current->next=pre;
                pre=current;
                current=_next;
                cnt++;
            }
            //这个时候，current和_next都指向下一个分段的开始
            if(current)
            {
                head->next=reverseKGroup(current,k);
            }
            
            //不要忘了这个
            return pre;
        }
        
        //否则，不可以反转，直接返回原来分段头节点即可
        else
            return head;
    }
};
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k<=1||!head||!head->next)
            return head;
        
        ListNode *pre=NULL;
        ListNode *cur=head;
        ListNode *next=NULL;
        ListNode *check=head;
        
        int count=0;
        int checkcount=0;
        
        while(checkcount<k&&check)
        {
            checkcount++;
            check=check->next;
        }
        
        if(checkcount==k)
        {
            while(count<k)
            {
                next=cur->next;
                cur->next=pre;
                pre=cur;
                cur=next;
                count++;
            }
            if(next)
            {
                head->next=reverseKGroup(next,k);
            }
            return pre;
        }
        
        else
            return head;
    }
};

、题目链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/

二 股票买卖问题

 股票买卖时机一

法一 动态规划思路

前i天的最大利润=max(前i-1天的最大利润，第i天股票的价值-前i天股票的最小值)

class Solution {
public:
    
    int solve(vector<int> &prices)
    {
        int res[prices.size()+1];
        memset(res,0,sizeof(res));
        int min_data=INT_MIN;
        int i;
        for(i=1;i<=prices.size();i++)
        {
            if(prices[i-1]<min_data)
                min_data=prices[i-1];
            res[i]=max(res[i-1],prices[i-1]-min_data);
        }
        return res[i-1];
    }
    
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1)
            return 0;
        else if(prices.size()==2&&prices[0]>=prices[1])
            return 0;
        else if(prices.size()==2&&prices[0]<prices[1])
            return prices[1]-prices[0];
        else
            return solve(prices);
    }
};

法二

维系2个变量，分别是利润最大值和股票价值的最小值（初始为第一支股票的价值）

之后遍历数组，（1）如果当前价值小于股票最小值，更新股票最小值

（2）否则即当前价值大于等于最小价值，则用当前值减去股票最小值与利润最大值做比较，判断是否更新即可。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1)
            return 0;
        int max_data=0;
        int min_data=prices[0];
        for(int i=1;i<prices.size();i++)
        {
            if(prices[i]<min_data)
                min_data=prices[i];
            else if(prices[i]-min_data>max_data)
                max_data=prices[i]-min_data;                
        }
        return max_data;
    }
};

股票买卖时机二

这个题目真的。。

[7, 1, 5, 6] 第二天买入，第四天卖出，收益最大（6-1），所以一般人可能会想，怎么判断不是第三天就卖出了呢? 这里就把问题复杂化了，根据题目的意思，当天卖出以后，当天还可以买入，所以其实可以第三天卖出，第三天买入，第四天又卖出（（5-1）+ （6-5） === 6 - 1）。所以算法可以直接简化为只要今天比昨天大，就卖出。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1)
            return 0;
        int res=0;
        int before=prices[0];
        for(int i=1;i<prices.size();i++)
        {
            if(prices[i]>before)
                res+=prices[i]-before;
            before=prices[i];
        }
        return res;
    }
};

股票买卖时机三

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=0)
            return 0;
        int release1=0;
        int release2=0;
        int hold1=INT_MIN;
        int hold2=hold1;
        
        for(int i=0;i<prices.size();i++)
        {
            int p=prices[i];
            hold1=max(hold1,-p);
            release1=max(release1,hold1+p);
            hold2=max(hold2,release1-p);
            release2=max(release2,hold2+p);
        }
        return release2;
    }
};

C/C++中基本数据类型极值的宏定义

思路就是维护4个变量，hold1,release1,hold2,release2来表示第一次买入股票/第一次出售股票/第二次买入股票/第二次卖出股票的收益最大值。遍历数组时，把该只股票当作4种情况都走一遍，然后release2就是最后的结果。

股票买卖的最佳时机四

限制k次交易

当k>=数组长度/2时，因为交易最频繁的情况时最多有数组长度/2次交易，比如3 5 2 7 4 9 2 6，即买进卖出交替进行。这是可以采取贪心算法，即买卖时机二的问题。

对于其它的k，可以采用买卖时机三的方法

class Solution {
public:
    
    int greedy(vector<int> &vec)
    {
        int before=vec[0];
        int res=0;
        for(int i=1;i<vec.size();i++)
        {
            if(vec[i]>before)
                res+=vec[i]-before;
            before=vec[i];
        }
        return res;
    }
    
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size()<=1||k<=0)
            return 0;
        if(k>=prices.size()/2)
            return greedy(prices);

        //a[i][0]  a[i][1]分别表示第i笔交易买入或卖出的最大利润
        int a[k][2];
        memset(a,0,sizeof(a));
        for(int i=0;i<k;i++)
        {
            a[i][0]=INT_MIN;
        }
        
        for(int i=0;i<prices.size();i++)
        {
            a[0][0]=max(a[0][0],-prices[i]);
            a[0][1]=max(a[0][1],a[0][0]+prices[i]);
            for(int j=1;j<k;j++)
            {
                a[j][0]=max(a[j][0],a[j-1][1]-prices[i]);
                a[j][1]=max(a[j][1],a[j][0]+prices[i]);
            }
        }
        return a[k-1][1];
    }
};

股票买卖的最佳时机（含有冷冻期）309

二维数组法

dp[k][3]

dp[k][0]表示现在手中有股票的最大利润
dp[k][1]表示现在（今天）刚卖出股票的最大利润
dp[k][2]表示今天处于冷冻期的最大利润或者虽然目前没有持有股票但是今天仍不买入（可以看作冷冻期）的最大利润

初始化
dp[0][0]=-prices[0]   //买入第一天的股票才保证手里有股票
dp[0][1]=0            //之前没有股票，所以是0
dp[0][2]=0           //今天处于冷冻期，但之前没有交易，所以为0

状态转移方程
dp[i][0]=max(dp[i-1][0],dp[i-1][2]-prices[i]);
//分别表示前一天已经有股票，前一天处于冷冻期今天买进

dp[i][1]=dp[i-1][0]+prices[i];
//只有一种情况就是前一天持有股票，今天卖出

dp[i][2]=max(dp[i-1][1],dp[i-1][2]);
//分别表示前一天卖出或前一天依然处于冷冻期内

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1)
            return 0;
        int dp[prices.size()][3];
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        dp[0][2]=0;
        
        for(int i=1;i<prices.size();i++)
        {
            dp[i][0]=max(dp[i-1][0],dp[i-1][2]-prices[i]);
            dp[i][1]=dp[i-1][0]+prices[i];
            dp[i][2]=max(dp[i-1][1],dp[i-1][2]);
        }
        return max(dp[prices.size()-1][1],dp[prices.size()-1][2]);
    }
};

股票买卖的最佳时机（含有手续费）714

二维数组法（动态规划法）

二维数组：dp[k][2] 

其中dp[k][0]表示在第k天持有股票的最大利润。

dp[k][1]表示在第k天不持有股票的最大利润。

状态转移方程如下：

dp[k][0]=max(dp[k-1][0],dp[k-1][1]-prices[k]);
//dp[k-1][0]表示第k-1天持有股票
//dp[k-1][1]表示第k-1天没有持有股票，需要在第k天买进

dp[k][1]=max(dp[k-1][1],dp[k-1][0]+prices[k]-fee);
//dp[k-1][1]表示第k-1天不持有股票
//dp[k-1][0]表示第k-1天持有股票，需要在第k天卖出股票

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        if(prices.size()<=1)
            return 0;
        int dp[prices.size()][2];
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        for(int i=1;i<prices.size();i++)
        {
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);
        }
        return dp[prices.size()-1][1];
    }
};

改进法

hold表示当天买进或不买进的最大利润

release表示当天卖出或不卖出的最大利润，卖出之前需要先买。买进来要先卖。

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        if(prices.size()<=1)
            return 0;
        int hold=INT_MIN;
        int release=0;
        for(int i=0;i<prices.size();i++)
        {
            hold=max(hold,release-prices[i]);
            release=max(release,prices[i]+hold-fee);
        }
        return release;
    }
};

三 接雨水

 题目链接

法一 

遍历数组，找出柱子高度的最大值。

然后从2端分别开始遍历直至到达柱子高度最大值为止。

比如，从首部开始遍历时，找到目前（局部）最大值，如果之后遍历的值比这个局部最大值小，就说明会填充雨水，填充的值就是局部最大值减去当前值。

class Solution {
public:
    int trap(vector<int>& height) {
        if(height.size()==0||height.size()==1||height.size()==2)
            return 0;
        
        int res=0;
        
        //找出最大值的下标
        int max_id=0;
        for(int i=1;i<height.size();i++)
        {
            if(height[i]>height[max_id])
                max_id=i;
        }
        
        //从首部开始遍历
        int max_par=0;
        for(int i=0;i<max_id;i++)
        {
            if(height[i]>max_par)
                max_par=height[i];
            else
                res+=max_par-height[i];
        }
        
        //从尾部开始遍历
        max_par=0;
        for(int i=height.size()-1;i>max_id;i--)
        {
            if(height[i]>max_par)
                max_par=height[i];
            else
                res+=max_par-height[i];
        }
        return res;
    }
};

法二

使用2个数组分别保存数组下标i之前的最大高度，i之后的最大高度

然后开始遍历数组，得出i之前的最大高度和i之后最大高度的最小值，以这个作为统一高度，如果该高度减去下标i对应的高度为负，结果不变，为正，结果更新即可。

class Solution {
public:
    int trap(vector<int>& height) {
        if(height.size()==0||height.size()==1||height.size()==2)
            return 0;
        vector<int> left(height.size());
        vector<int> right(height.size());
        int res=0;
        
        for(int i=1;i<height.size();i++)
        {
            left[i]=max(height[i-1],left[i-1]);
        }
        
        for(int i=height.size()-2;i>=0;i--)
        {
            right[i]=max(height[i+1],right[i+1]);
        }
        
        for(int i=0;i<height.size();i++)
        {
            int num=min(left[i],right[i]);
            res+=max(0,num-height[i]);
        }
        return res;
    }
};

 

带你去网吧里偷耳机
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode中文版-LeetCode-Notebook:https://leetcode-cn.com/u/ml-zimingmeng/
06-29
「LeetCode-习题集」使用说明 | 中文说明 简介 「LeetCode-习题集」是由热爱算法的 LeetCoders 上传的代码集，我们的目标是贡献所有题解！如果您想成为代码贡献者，体会 GitHub 协同合作的乐趣，请阅读 中的提交准则...
链表题目：K 个一组反转链表
stormsunshine的博客
03-24 1560
文章目录题目标题和出处难度题目描述要求示例数据范围进阶解法一思路和算法代码复杂度分析解法二思路和算法代码复杂度分析 题目 标题和出处 标题：K 个一组反转链表 出处：25. K 个一组反转链表 难度 4 级 题目描述 要求 给你一个链表，每 k\texttt{k}k 个结点一组进行反转，并返回反转后的链表。 k\texttt{k}k 是一个正整数，它的值小于或等于链表的长度。如果结点总数不是 k\texttt{k}k 的倍数，那么请将最后剩余的结点保持原有顺序。 不能修改结点的值，只能修改结点本身。 示例
LeetCode 25K 个一组翻转链表&26删除排序数组中的重复项
bigsai
09-13 2464
如果问题或者其他方法还请分享，如加入打卡微信搜索bigsai回复进群一起打卡。 K个一组翻转链表 题目要求 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例： 给你这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3->2-&g.
单链表分段逆转（画图分析）
2302_79372568的博客
02-29 594
其中List/* 存储结点数据 *//* 指向下一个结点的指针 *//* 定义单链表类型 */L是给定的带头结点的单链表，K是每段的长度。函数K_Reverse应将L中的结点按要求分段逆转。
LeetCode: K 个一组翻转链表 python实现
weixin_43786241的博客
04-21 465
1. 题目描述 K 个一组翻转链表：         给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。         k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例：         给你...
[LeetCode] K Inverse Pairs Array K个翻转对数组
weixin_34368949的博客
07-03 104
  Given two integers n and k, find how many different arrays consist of numbers from 1 to n such that there are exactly k inverse pairs. We define an inverse pair as following: For ith and jth eleme...
Leetcode 25:k个一组翻转链表（最详细解决方案！！！）
热门推荐
coordinate的博客
06-14 1万+
给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。 示例 : 给定这个链表：1-&amp;gt;2-&amp;gt;3-&amp;gt;4-&amp;gt;5 当 k = 2 时，应当返回: 2-&amp;gt;1-&amp;gt;4-&amp;gt;3-&amp;gt;5 当 k = 3 时
c++-c++编程基础之leetcode题解第25题K个一组反转链表.zip
最新发布
04-07
c++ c++_c++编程基础之leetcode题解第25题K个一组反转链表
zwangZJU#LeetCode-in-python-wznote#LeetCode-python-23-合并K个排序链表1
07-25
示例输入:输出: 1->1->2->3->4->4->5->6解题思路将k个链表建立成一个最小堆，再从堆顶pop()出每一个元素，连接成链表heapq是pyth
leetcode中国-InterView_Problem:LeetCode/NowCoder/Timus...问题代码。（主要是Java实现）
06-29
leetcode中国 InterView_Problem English LeetCode / NowCoder / Timus ... Problems code. （Mainly Java implementation） Chinese 刷题代码，主要是java实现，可能会有其他语言代码 ...LeetCode-cn
leetcode下载-LeetCode-Python-Java:zhouzhenping/LeetCode-Python&Java
06-29
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: ...
leetcode 25 k 个一组翻转列表
zshluckydogs的博客
07-01 162
题目描述 给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。 k是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是k的整数倍，那么请将最后剩余的节点保持原有顺序。 示例： 给你这个链表：1->2->3->4->5 当k= 2 时，应当返回: 2->1->4->3->5 当k= 3 时，应当返回: 3->2->1->4->5 说明： 你的算法只能使用常数的额外空间。 你不...
LeetCode 25.k个一组翻转链表(Reverse Nodes in k-Group)
墨1024
03-18 258
LeetCode.jpg k个一组翻转链表 给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。 示例 : 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5...
数组元素反转附图
weixin_44873998的博客
09-21 89
[Leedcode][JAVA][第25题][K个一组反转链表][链表][递归]
dadongwudi的博客
05-21 170
【问题描述】[第25题][K个一组反转链表][困难] 时间复杂度：O(N^2) 空间复杂度：O(1) ```java 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例： 给你这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回
将数组进行k个数的倒转，算法效率优先
零点°C的博客
09-13 967
对于该算法的实现，希望大家予以赐教，我是新人，大家有更好的实现方法，希望不吝批评 对于思路大概分为两种 1、若考虑能够分配额外的空间，则通过指针（index）进行copy动作即可，算法的实现复杂度为O(n) 2、若不需要额外的空间，且使得效率为线性效率呢 例如k=2 [1,2,3,4,5,6]->[6,5,4,3,2,1]->[5,6,4,3,2,1]->[5,6,1,2,3,4]
算法练习--k个一组翻转链表
QilanAllen的博客
05-18 230
题目： 给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。 k是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是k的整数倍，那么请将最后剩余的节点保持原有顺序。 示例： 给你这个链表：1->2->3->4->5 当k= 2 时，应当返回: 2->1->4->3->5 当k= 3 时，应当返回: 3->2->1->4->5 个人思路： 我的解法有两种，代码中注释的是一种，没注释的是另...
Leetcode刷题(k个一组翻转链表、字节跳动往年的真题)
星的博客
09-08 164
k个一组翻转链表 题目一描述 给定一个链表，将链表中的k个元素进行翻转，最后不满足k个元素的整数倍的元素，不进行翻转。 例如： 输入：1->2->3->4->5 k=2时： 返回2->1->4->3->5 k=3时：返回3->2->1->4->5 题目传送 题目一分析 该题目是一道困难的题目，但是对于链表这种数据结构的题目一般都不是特别难。可以使用一个指针窗口进行翻转窗口内的所有节点，但是这样的做题需要多个指针，比较乱。 我使用额
https://leetcode-cn.com/tag/dynamic-programming/
06-28
在 LeetCode 上，动态规划也是一个非常重要的题型，很多题目都需要用到动态规划的思想来解决。 这个链接里包含了很多关于动态规划的题目，按照难度从简单到困难排列。每个题目都有详细的题目描述、输入输出样例、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值