LeetCode--任务4--双指针技术

最新推荐文章于 2024-03-09 22:00:54 发布
最新推荐文章于 2024-03-09 22:00:54 发布
阅读量241 收藏
点赞数
分类专栏： # 天池 人工智能 # Kaggle 文章标签： 算法 python leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41491023/article/details/108071728
版权
人工智能 同时被 3 个专栏收录
47 篇文章 0 订阅
订阅专栏
天池
37 篇文章 0 订阅
订阅专栏
Kaggle
14 篇文章 0 订阅
订阅专栏

双指针技术在求解算法题中的应用

1 C# 和 Python 中的链表结构

Python list 的源码地址：

https://github.com/python/cpython/blob/master/Include/listobject.h

https://github.com/python/cpython/blob/master/Objects/listobject.c

C# List<T> 的源码地址：

https://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,cf7f4095e4de7646

通过阅读源码，我们发现 Python 的 list 与 C# 的 List<T> 一致都是通过动态数组的方式来实现的。

Python 的内置结构中没有链表这种结构，而C# 的内置结构中封装了双向链表 LinkedList<T>，内部结点为 LinkedListNode<T>，源码地址如下：

https://referencesource.microsoft.com/#System/compmod/system/collections/generic/linkedlist.cs,df5a6c7b6b60da4f

LinkedListNode<T>

  • public LinkedListNode<T> Next { get; } -> 获取下一个节点

  • public LinkedListNode<T> Previous { get; } -> 获取上一个节点

  • public T Value { get; set; } -> 获取或设置包含在节点中的值。

LinkedList<T>

  • public LinkedListNode<T> AddFirst(T value); -> 添加包含指定的值的开头的新节点

  • public LinkedListNode<T> AddLast(T value); -> 添加包含指定的值的末尾的新节点

  • public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T value); -> 添加包含在指定的现有节点前的指定的值的新节点

  • public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T value); -> 添加包含指定的值中指定的现有节点后的新节点

  • public void AddFirst(LinkedListNode<T> node); -> 将指定的新节点添加的开头

  • public void AddLast(LinkedListNode<T> node); -> 将指定的新节点添加的末尾

  • public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode); -> 在指定的现有节点之前添加指定的新节点

  • public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode); -> 在指定的现有节点之后添加指定的新节点

  • public bool Remove(T value); -> 移除从指定的值的第一个匹配项

  • public void Remove(LinkedListNode<T> node); -> 移除指定的节点

  • public void RemoveFirst(); -> 删除的开始处的节点

  • public void RemoveLast(); -> 删除节点的末尾

  • public LinkedListNode<T> Find(T value); -> 查找包含指定的值的第一个节点。

  • public LinkedListNode<T> FindLast(T value); -> 查找包含指定的值的最后一个节点。

  • public void Clear(); -> 删除所有节点

  • public int Count { get; } -> 获取中实际包含的节点数

  • public LinkedListNode<T> First { get; } -> 获取的第一个节点

  • public LinkedListNode<T> Last { get; } -> 获取的最后一个节点

public static void LinkedListSample()
{
    LinkedList<int> lst = new LinkedList<int>();
    lst.AddFirst(3);
    lst.AddLast(1);
    lst.AddLast(4);
    foreach (int item in lst)
    {
        Console.Write(item+" "); 
    }
    Console.WriteLine();
    
    LinkedListNode<int> cur = lst.Find(3);
    lst.AddBefore(cur, 2);
    foreach (int item in lst)
    {
        Console.Write(item + " "); 
    }
    Console.WriteLine();
    
    lst.Remove(3);
    foreach (int item in lst)
    {
        Console.Write(item + " "); 
    }
    Console.WriteLine();
    lst.Clear();
}
​
// 3 1 4
// 2 3 1 4
// 2 1 4

 

2 反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

进阶:

你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

思路：利用双指针的方式

p1作为前面的指针探路，p2作为后面的指针跟进，顺着链表跑一圈，搞定问题。

C# 语言

  • 状态：通过

  • 27 / 27 个通过测试用例

  • 执行用时: 116 ms, 在所有 C# 提交中击败了 97.50% 的用户

  • 内存消耗: 23.3 MB, 在所有 C# 提交中击败了 5.26% 的用户

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
​
public class Solution
{
    public ListNode ReverseList(ListNode head)
    {
        if (head == null || head.next == null)
            return head;
            
        ListNode p1 = head;
        ListNode p2 = null;
        while (p1 != null)
        {
            ListNode temp = p1.next;
            p1.next = p2;
            p2 = p1;
            p1 = temp;
        }
        return p2;
    }
}

Python 语言

  • 执行结果：通过

  • 执行用时：36 ms, 在所有 Python3 提交中击败了 92.27% 的用户

  • 内存消耗：14.6 MB, 在所有 Python3 提交中击败了 17.65% 的用户

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
​
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head is None or head.next is None:
            return head
        p1 = head
        p2 = None
        while p1 is not None:
            temp = p1.next
            p1.next = p2
            p2 = p1
            p1 = temp
        return p2

3 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第n个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.
​
当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的n保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

思路：利用双指针的方式

使用两个指针，前面的指针p1先走n步，接着让后面的指针p2与p1同步走，p1走到终点，p2即走到要移除的结点位置。

C# 语言

  • 执行结果：通过

  • 执行用时：104 ms, 在所有 C# 提交中击败了 86.93% 的用户

  • 内存消耗：24.6 MB, 在所有 C# 提交中击败了 100.00% 的用户

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution 
{
    public ListNode RemoveNthFromEnd(ListNode head, int n) 
    {
        ListNode p1 = head;
        ListNode p2 = head;
        
        while (n > 0)
        {
            p1 = p1.next;
            n--;
        }
​
        if (p1 == null) //移除头结点
        {
            return head.next;
        }
            
        while (p1.next != null)
        {
            p1 = p1.next;
            p2 = p2.next;
        }
            
        p2.next = p2.next.next;
        return head;
    }
}

Python 语言

  • 执行结果：通过

  • 执行用时：48 ms, 在所有 Python3 提交中击败了 23.58% 的用户

  • 内存消耗：13.5 MB, 在所有 Python3 提交中击败了 7.83% 的用户

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
​
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        p2 = head
        p1 = head
        while (n > 0):
            p1 = p1.next
            n -= 1
​
        if (p1 is None):  # 移除头结点
            return head.next
​
        while (p1.next):
            p2 = p2.next
            p1 = p1.next
​
        p2.next = p2.next.next
        return head

4 删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

思路：利用双指针的方式

p1作为前面的指针探路，p2作为后面的指针跟进，如果遇到重复元素，p2.next跳过去，p1跑完整个链表所有重复元素都被摘下来。

C# 语言

  • 执行结果：通过

  • 执行用时：160 ms, 在所有 C# 提交中击败了 5.23% 的用户

  • 内存消耗：25.9 MB, 在所有 C# 提交中击败了 5.72% 的用户

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
 
public class Solution
{
    public ListNode DeleteDuplicates(ListNode head)
    {
        if (head == null)
            return head;
​
        ListNode p1 = head.next;
        ListNode p2 = head;
        while (p1 != null)
        {
            if (p1.val == p2.val)
                p2.next = p1.next;
            else
                p2 = p2.next;
            p1 = p1.next;
        }
        return head;
    }
}

Python 语言

  • 执行结果：通过

  • 执行用时：52 ms, 在所有 Python3 提交中击败了 33.88% 的用户

  • 内存消耗：13.5 MB, 在所有 Python3 提交中击败了 12.75% 的用户

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
​
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if head is None:
            return head
            
        p1 = head.next
        p2 = head
        while p1 is not None:
            if p1.val == p2.val:
                p2.next = p1.next
            else:
                p2 = p2.next
            p1 = p1.next
        return head

5 环形链表

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果pos是 -1，则在该链表中没有环。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

思路：利用双指针的方式

通常情况下，判断是否包含了重复的元素，我们使用Hash的方式来做。对于单链表的这种场景，我们也可以使用双指针的方式。

第一个指针 p1 每次移动两个节点，第二个指针 p2 每次移动一个节点，如果该链表存在环的话，第一个指针一定会再次碰到第二个指针，反之，则不存在环。

比如：head = [1,2,3,4,5]，奇数

p1：1   3   5   2   4   1
p2：1   2   3   4   5   1

比如：head = [1,2,3,4]，偶数

p1：1   3   1   3   1
p2：1   2   3   4   1

C# 语言

  • 状态：通过

  • 执行用时: 112 ms, 在所有 C# 提交中击败了 98.43% 的用户

  • 内存消耗: 24.9 MB, 在所有 C# 提交中击败了 5.13% 的用户

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public bool HasCycle(ListNode head) {
        ListNode p1 = head;
        ListNode p2 = head;
​
        while (p1 != null && p1.next != null)
        {
            p1 = p1.next.next;
            p2 = p2.next;
            if (p1 == p2)
                return true;
        }
        return false;
    }
}

Python 语言

  • 执行结果：通过

  • 执行用时：56 ms, 在所有 Python3 提交中击败了 60.97% 的用户

  • 内存消耗：16.6 MB, 在所有 Python3 提交中击败了 11.81% 的用户

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
​
class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        p1 = head
        p2 = head
        while p1 is not None and p1.next is not None:
            p1 = p1.next.next
            p2 = p2.next
            if p1 == p2:
                return True
        return False

 

 

 

 

6 排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

思路：模仿并归排序的思路，典型的回溯算法。

如果待排的元素存储在数组中，我们可以用并归排序。而这些元素存储在链表中，我们无法直接利用并归排序，只能借鉴并归排序的思想对算法进行修改。

并归排序的思想是将待排序列进行分组，直到包含一个元素为止，然后回溯合并两个有序序列，最后得到排序序列。

对于链表我们可以递归地将当前链表分为两段，然后merge，分两段的方法是使用双指针法，p1指针每次走两步，p2指针每次走一步，直到p1走到末尾，这时p2所在位置就是中间位置，这样就分成了两段。

C# 语言

  • 状态：通过

  • 16 / 16 个通过测试用例

  • 执行用时: 124 ms, 在所有 C# 提交中击败了 100.00% 的用户

  • 内存消耗: 29 MB, 在所有 C# 提交中击败了 25.00% 的用户

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
 
public class Solution
{
    public ListNode SortList(ListNode head)
    {
        if (head == null)
            return null;
        return MergeSort(head);
    }
    
    private ListNode MergeSort(ListNode node)
    {
        if (node.next == null)
        {
            return node;
        }
        ListNode p1 = node;
        ListNode p2 = node;
        ListNode cut = null;
        while (p1 != null && p1.next != null)
        {
            cut = p2;
            p2 = p2.next;
            p1 = p1.next.next;
        }
        cut.next = null;
        ListNode l1 = MergeSort(node);
        ListNode l2 = MergeSort(p2);
        return MergeTwoLists(l1, l2);
    }
​
    private ListNode MergeTwoLists(ListNode l1, ListNode l2)
    {
        ListNode pHead = new ListNode(-1);
        ListNode temp = pHead;
​
        while (l1 != null && l2 != null)
        {
            if (l1.val < l2.val)
            {
                temp.next = l1;
                l1 = l1.next;
            }
            else
            {
                temp.next = l2;
                l2 = l2.next;
            }
            temp = temp.next;
        }
​
        if (l1 != null)
            temp.next = l1;
​
        if (l2 != null)
            temp.next = l2;
​
        return pHead.next;
    }
}

Python 语言

  • 执行结果：通过

  • 执行用时：216 ms, 在所有 Python3 提交中击败了 75.99% 的用户

  • 内存消耗：20.7 MB, 在所有 Python3 提交中击败了 28.57% 的用户

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
​
class Solution:
    def sortList(self, head: ListNode) -> ListNode:
        if head is None:
            return head
        return self.mergeSort(head)
​
    def mergeSort(self, node: ListNode) -> ListNode:
        if node.next is None:
            return node
        p1 = node
        p2 = node
        cute = None
        while p1 is not None and p1.next is not None:
            cute = p2
            p2 = p2.next
            p1 = p1.next.next
        cute.next = None
        l1 = self.mergeSort(node)
        l2 = self.mergeSort(p2)
        return self.mergeTwoLists(l1, l2)
​
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        pHead = ListNode(-1)
        temp = pHead
        while l1 is not None and l2 is not None:
            if l1.val < l2.val:
                temp.next = l1
                l1 = l1.next
            else:
                temp.next = l2
                l2 = l2.next
            temp = temp.next
​
        if l1 is not None:
            temp.next = l1
        if l2 is not None:
            temp.next = l2
​
        return pHead.next
迷途小龙驹
关注
专栏目录
LeetCode 移动零（双指针+图解）
hestyle的博客
03-06 645
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明: 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。 思路分析：使用两个指针，一个指针扫描数组，一个指针用于指向移动好的非零序列的尾端。 图解示例 class Solution { public: ...
LeetCode笔记---Java语言-＞线程池与任务队列（队列)
ljy320672584的博客
07-31 335
LeetCode笔记—Java语言-＞线程池与任务队列->622. 设计循环队列 栈的简述： 队列：是一片连续的存储区域（有一个头指针，一个尾指针->最后一个元素的下一位）FIFO-先入先出。 队列-假溢出：队列中还有空的位置，只是因为尾节点走到了最后一位。 循环队列：（走到尾部在从头开始）：为了解决队列假溢出。 队列的典型应用场景（通常用在缓冲区用途）： 1.CPU的超线程技术 2.线程池的任务队列（函数式编程思想-范型编程思想）： 此题思路 略 class MyCircu
LeetCode--任务7--排序技术
qq_41491023的博客
08-18 215
排序技术在求解算法题中的应用 1 C# 和 Python 中的排序操作 C# 中的排序 对集合类的排序，我们通常使用位于 System.Core 程序集，System.Linq命名空间下，Enumerable静态类中的扩展方法。 public static class Enumerable { public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TS..
leetcode-算法刷题笔记
温柔一刀
09-12 164
官方网址http://leetcode-solution.cn/book 文前 [1]https://chrome.google.com/webstore/detail/leetcodecheatsheet/fniccleejlofifaakbgppmbbcdfjonl 正文 [1] https://github.com/azl397985856/leetcode/blob/master/daily/2019-07-31.md [2] https://leetcode-cn.com/problems/ad
LeetCode-Hot100
最新发布
weixin_43038557的博客
03-09 647
因为是字母异位词，因为把他们提取出来做个排序，得到的字符串肯定是相等的，因此我们可以利用HashMap的key-value的数据结构，把排序后的字符串作为key，这样遍历到数组中的字符串时，先做个排序，然后查询下HashMap中是否有该字符串，有的话就把他加入到该key的value中，因为value里面可能存放不止一个字符串，因此构建HashMap的时候valu的结构需要是List，这样遍历一遍之后就一键分类完成了。字母异位词是由重新排列源单词的所有字母得到的一个新单词。
LeetCode--哈希表--242,383，49，438
飞翔的胖迪
05-05 211
问题分析 我以为我的链表那一章还能有个第二节，做到后面发现跟我前面发的几个什么反转链表一样，就没有继续做了。就往下做了哈希表这部分，哈希表的话，做完之后我觉得跟前面的滑动窗口还有点关系，那里面存储也用的哈希表：key-value。 这里主要是涉及到242,383,49,438题，难点的题就是49，这个真是一个medium做一天。后面分析。 思路分析 遇到某个元素是否在数组中出现就用哈希法。我理解的是一个字符出现次数需要计数的时候，哈希法就用到了。 第一题第二题只要知道这个字符串转化为字符数组的方法就
[JavaEE]初始操作系统--进程
Node_Hao的博客
11-30 2881
由于JavaEE涉及许多计算机操作系统中多线程的知识 , 本文作为javaEE的第一篇文章 , 旨在了解多线程的基础知识 , 为后续JavaEE并发编程的学习打好基础.javaEE是基于javaSE基础构建的, 用来实现企业级和Web应用级企业的开发, 它不是编程语言而是一系列的技术规范和实现, 技术平台的核心思想是容器加组件.一个运行起来的程序 , 就可以称之为"进程" , 如果没运行起来就只能叫程序. 同时 , 在操作系统内部 ,进程又是操作系统进行资源分配的基本单位.
刻意练习：LeetCode实战 -- Task03. 移除元素
老马的程序人生
03-01 622
背景 本篇图文是LSGO软件技术团队组织的 第二期基础算法（Leetcode）刻意练习训练营 的打卡任务。本期训练营采用分类别练习的模式，即选择了五个知识点（数组、链表、字符串、树、贪心算法），每个知识点选择了 三个简单、两个中等、一个困难 等级的题目，共计三十道题，利用三十天的时间完成这组刻意练习。 本次任务的知识点：数组 数组 是在程序设计中，为了处理方便，把具有相同类型的若干元素按有序的形式...
LeetCode习题总结-算法（17）
Andrew_Shiba_Inu的博客
06-14 642
第十七天LeetCode刷题-算法 第十七天习题——求给定字符串的最大回文子串 此题仅为个人总结参考，如有错误还请指出 首先先上原题： 来源：力扣（LeetCode） 原题链接：https://leetcode-cn.com/problems/longest-palindromic-substring/ ...
颜色分类leetcode-leetcode-algorithms:leetcode-算法
07-06
这个问题通常可以用一次或两次遍历来解决，比如使用双指针技巧或者借助于哈希映射来辅助处理。 在LeetCode上，算法被分为三个难度级别：Easy、Medium和Hard。这表明颜色分类问题可能有不同层次的复杂度，初级版本...
leetcode卡-LeetCode-June-Challenge:它由6月份的30道日常问题组成
07-06
通过参与 LeetCode 的 June Challenge 并研究提供的代码，不仅可以提升 C++ 编程技能，还能增强解决实际问题的能力，为面试和工作中的技术挑战做好准备。此外，这样的开源项目也提供了学习其他开发者解决问题的思路...
LeetCode-problems:LeetCode问题
03-29
例如，数组相关的题目可能会涉及单向遍历、双指针技术、滑动窗口等技巧；链表问题常常涉及节点操作，如插入、删除、反转、合并等；字符串问题可能涵盖模式匹配、动态规划等；而二叉树问题则可能包括遍历、搜索、平衡...
leetcode-solutions:用JavaScript实现的LeetCode问题的演练解决方案
04-29
例如，使用双指针技术解决两数之和问题，或者使用reduce函数进行数组的聚合计算。 5. **字符串处理**：JavaScript字符串处理也是LeetCode中常见的考点，如反转字符串、检查回文、替换空格等。字符串的split、join、...
leetcode-interviews:我解决的所有Leetcode问题
05-17
- 链表：链表问题考察了对指针操作的理解，包括单链表、双链表的遍历、反转和合并。 - 栈与队列：利用栈的后进先出（LIFO）特性解决回溯问题，队列的先进先出（FIFO）特性用于处理任务调度和广度优先搜索。 - 树...
第一章 强化学习介绍
qq_41491023的博客
10-20 3345
Reinforement Learning Reinforcement Learning 强化学习讨论的问题是一个 智能体(agent) 怎么在一个复杂不确定的环境(environment)里面去极大化它能获得的奖励。示意图由两部分组成：agent 和 environment。在强化学习过程中，agent 跟 environment 一直在交互。Agent 在环境里面获取到状态，agent 会利用这个状态输出一个 action，一个决策。然后这个决策会放到环境之中去，环境会通过这个 agent 采取的决
计算机视觉基础---图像处理（下）---任务03
qq_41491023的博客
08-13 2108
Haar特征描述算子-人脸检测 3.1简介 Haar-like特征最早是由Papageorgiou等应用于人脸表示，在2001年，Viola和Jones两位大牛发表了经典的《Rapid Object Detection using a Boosted Cascade of Simple Features》和《Robust Real-Time Face Detection》，在AdaBoost算法的基础上，使用Haar-like小波特征和积分图方法进行人脸检测，他俩不是最早使用提出小波特征的，但是他们设计
第三章 策略梯度及 PPO 算法
qq_41491023的博客
10-29 1724
Policy Gradient Policy Gradient 在 reinforcement learning 中有 3 个components，一个actor，一个environment，一个reward function。 让机器玩 video game 时， actor 做的事情就是去操控游戏的摇杆， 比如说向左、向右、开火等操作； environment 就是游戏的主机， 负责控制游戏的画面负责控制说，怪物要怎么移动， 你现在要看到什么画面等等； reward.
第三章 DQN算法及Actor-Critic算法
qq_41491023的博客
11-02 1373
Double DQN 接下来要讲的是 train Q-learning 的一些 tip。第一个 tip 是做 Double DQN。那为什么要有 Double DQN 呢？因为在实现上，你会发现 Q value 往往是被高估的。上图来自于 Double DQN 的原始 paper，它想要显示的结果就是 Q value 往往是被高估的。 这边有 4 个不同的小游戏，横轴是 training 的时间，红色锯齿状一直在变的线就是 Q-function 对不同的 state estimate 出来的平均 .
第二章 马尔可夫决策过程及表格型方法
qq_41491023的博客
10-23 1249
马尔可夫决策过程。 在介绍马尔可夫决策过程之前，先介绍它的简化版本：马尔可夫链以及马尔可夫奖励过程，通过跟这两种过程的比较，我们可以更生动地理解马尔可夫决策过程。 第二部分会介绍马尔可夫决策过程中的 policy evaluation，就是当给定一个决策过后，怎么去计算它的价值函数。 第三部分会介绍马尔可夫决策过程的控制，具体有两种算法：policy iteration 和 value iteration。 上图介绍了在强化学习里面 agent 跟 environment.
LeetCode双人赛与算法实践-掌握必备数据结构
双链表是链表的一种改进形式，其节点除了有指向前一个节点的指针外，还有指向下一个节点的指针。这种数据结构允许从两个方向进行遍历，可以更快地进行插入和删除操作，尤其是在链表的中间位置。 **技术面试** 技术...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值