fast

/* 判断单链表是否存在环 1）暴力：双层循环遍历（n^2） 2）双指针：快指针fast=NULL,慢指针slow=NULL int judge(link head) { if(NULL==head) return false; link fast = head, slow = head; while(slow!=NULL && fast!=NULL) { slow = slow->next; fast = fast->next->next; if(slow==fast) { return true; } } return false; } 计算带环单链表的长度 int count(link head) { if(NULL==head) return false; link fast = head, slow = head; while(slow!=NULL && fast!=NULL) { slow = slow->next; fast = fast->next->next; if(slow==fast) { flag = true; break; } } if(flag) { int ans = 1; slow = slow->next; while(slow!=fast) { ans++; slow = slow->next; } return ans ; } return

该系列核心思想为候选区域,即先找出候选区域, 再在候选区域上进行目标检测 1.R-CNN 基于候选区域的目标检测 通过选择性搜索算法, 对输入图像选取2000个候选区域 在每一个候选区域上进行卷积提取特征 对提取的特征分别做(1)svm分类, (2)线性回归bbox 因为对每一个候选区域做重复的事情, 切选择性搜索, 所以速度很慢 2.Fast RCNN 相对RCNN主要做了两个改进, 使的速度加快了. 直接对输入图片深层卷积提取特征, 在特征上进行选择性搜索获取ROI, 这样只用提取一次特征, 原来需要2000次.即一次提取特征+多任务学习. 使用softmax分类器替换svm, 结果没有降低, 加快了速度 ROI pooling 用于将不同尺寸的POI通过池化后, 变成一样的尺寸.如 未解决的问题, ROI搜索算法 问题:多个roi池化后多任务学习怎么进行的? 3.Faster-RCNN 主要提出了RPN网络,用深度学习生成ROI, 取代选择搜索算法.可以理解为Faster-RCNN = rpn + fast-rcnn 原文这个conv feature map的维度是13*13*256的； 作者在文章中指出，sliding window的大小是3*3的，那么如何得到这个256-d的向量呢？ 这个很简单了，我们只需要一个3*3*256*256这样的一个4维的卷积核

做LeetCode碰到两个快慢指针运用的题目，记录一下，当然这个东西应用的地方肯定不止下面这两个了，以后要是碰到就再更新 快慢指针： 这里快慢实际是指他们移动的步数，一个一次移动多个位置（一般二），一个移动一个 1，判断链表里是否存在环 题目描述： 给定一个链表，判断链表中是否有环。 pos pos -1 ，则在该链表中没有环。 思路：快指针和慢指针同时往链表后面移动，如果快指针到达NULL，说明链表以NULL为结尾，没有环。如果快指针追上慢指针（即两个相等），则表示有环。 代码： /** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */ public class Solution { public boolean hasCycle(ListNode head) { if (head==null) { return false; } ListNode slow = head; ListNode fast = head; while(fast!=null&&fast.next!=null) { slow = slow.next; fast = fast

题目 给定一个链表，判断链表中是否有环。 进阶： 你能否不使用额外空间解决此题？ 解题 使用快慢指针, 如果两个指针再次发生碰撞, 则表示链表中有环 /** * 141. 环形链表 */ public class Solution { public boolean hasCycle ( ListNode head ) { if ( head == null || head . next == null ) { return false ; } // 快慢指针, 如果快慢指针再次碰撞说明有环 ListNode slow = head , fast = head ; while ( fast != null && fast . next != null ) { // 先移动再比较是为了跳过head节点 slow = slow . next ; fast = fast . next . next ; if ( fast == slow ) { return true ; } } return false ; } } 来源： CSDN 作者： 七夜丶雪 链接： https://blog.csdn.net/love905661433/article/details/84797850

LeetCode 234. 回文链表 请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 进阶： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ Python方法 使用快慢指针找到链表中点。 逆序后半部分。 两部分从头结点开始比较是否相同。 class ListNode : def __init__ ( self , x ) : self . val = x self . next = None class Solution : def isPalindrome ( self , head : ListNode ) - > bool : fast = slow = head # 找到中间的节点 while fast and fast . next : fast = fast . next . next slow = slow . next # 后半段逆序 pre = None nxt = None while slow : nxt = slow . next slow . next = pre pre = slow slow = nxt # 比较前半段和后半段节点 while pre and head : if pre . val != head . val : return

Fast Online Object Tracking and Segmentation: A Unifying Approach Paper ： https://arxiv.org/pdf/1812.05050 Code（Test Only） ： https://github.com/foolwood/SiamMask Blog ： https://zhuanlan.zhihu.com/p/58154634 这篇博文主要从 Tracking 的角度来看待这个跟踪算法，具体分割算法请参考原文。 本文提出一种多任务框架，来实现同时跟踪与分割，初步探索了目标的表达对跟踪结果的影响。具体效果如下图所示： 究其根本，就是在想怎么用更好的 Bounding Box 框柱物体，以适应物体的形变等导致的跟踪不准确的问题。当上一帧的跟踪结果靠谱时，那么当前帧就可以进行很好的采样，跟踪。作者在 Siamese Net based tracker 的基础上，进一步引入 Mask branch，得到分割结果。然后在此基础上，进行跟踪。这一步，其实相当于一定程度上解决了目标尺度变化的问题。其跟踪框架的大致流程如下所示： 其实，貌似就是这样简单。但是由于 Siamese tracker 效率很高，加上分割的分支之后，速度也没有变慢很多。但是，在 VOT 的跟踪数据集上，取得了很好的跟踪效果。 总结：

Git 很是强大，在体验过rebase的华丽之后，再次发现之前在TFS上遇到的问题一下都有解了。但也印证了Git深入并非易事。这篇就谈下一个容易迷糊的概念：Fast forward。 Fast-Forward 当前分支合并到另一分支时，如果没有分歧解决，就会直接移动文件指针。这个过程叫做fast forward。 举例来说，开发一直在master分支进行，但忽然有一个新的想法，于是新建了一个develop的分支，并在其上进行一系列提交，完成时，回到 master分支，此时，master分支在创建develop分支之后并未产生任何新的commit。此时的合并就叫fast forward。 示例： 1. 新建一个work tree，在master中做几次commit 2. 新建develop的branch，然后再做多次commits 此时的分支流图如下 ( gitx )： 正常合并 (master)$ git merge develop Updating 5999848..7355122 Fast-forward c.txt | 1 + d.txt | 1 + 2 files changed, 2 insertions(+), 0 deletions(-) create mode 100644 c.txt create mode 100644 d.txt 可以看出这是一次fast

题目 请判断一个链表是否为回文 链表 ： 时间复杂度O(n) 空间复杂度O(1) 快慢指针 快慢指针非常适合这种有中点的问题，并且在移动快慢指针的过程，将原有的链表拆成了两部分(注意：对原链表进行了操作，若为工程不该这么做，但是题目要求空间复杂度O(1))，然后再往后逐一比较。 注意点： 头插法 奇偶情况不同 def isPalindrome ( self , head : ListNode ) - > bool : if ( not head or not head . next ) : return True pre = None # 和 slow 同步 curr = None # 记录新链的头(头插法) fast = slow = head while fast and fast . next : # fast不为空的判断一定要有且在前，根据：逻辑短路 pre = slow slow = slow . next fast = fast . next . next pre . next = curr # 让新点插到新链表的头 curr = pre # 让新点成为新链的头 # while结束，此时slow指向中点，而fast指向最后，若fast不为空，则链表长为奇 if fast : slow = slow . next # 若为奇数，则slow在中点

上题目： leetcode 141 简单 总体思路： 双指针，即通过使用一快一慢不同速度的两个指针来遍历链表，如果有环，快的总会与慢的相遇。 上代码： 1 class Solution: 2 def has_cycle(self, head): 3 """ 4 :type head:ListNode 5 :rtype:bool 6 """ 7 if head == None: 8 return False 9 10 fast, slow = head, head 11 # 这里快指针fast一次走两步，慢指针slow一次走一步 12 while fast.next != None and fast.next.next != None: 13 slow = slow.next 14 fast = fast.next.next 15 if slow == fast: 16 return True 17 18 return False 来源： https://www.cnblogs.com/xiaowei2092/p/11720711.html

思路： 用两个指针fast和slow指针（快慢指针），开始的时候指针都指向链表的Head节点，然后在每一步的操作中slow向前走一步：slow = slow.Next, 而fast就向前走两步 ：fast = fast.Next.Next; 快指针fast由于比慢指针slow快，所以fast一定比slow先进入环 也就是说，slow每次向前走一步，fast向前追了两步，因此每一步操作后fast到slow的距离缩短了1步，这样继续下去就会使得两者之间的距离逐渐减小，最后会在环中相遇； 复杂度： 时间复杂度 ：需要循环N次，所以时间复杂度未O(n)； 空间复杂度 ：除了链表本身需要的内存空间外，并不需要其他的内存空间地址，所以空间复杂度为O(1); public bool CycleList() { //链表为空，或是单结点链表只有一个节点 if (Head == null || Head.Next == null) { return false; } Node<T> temp = Head; Node<T> fast = temp; Node<T> slow = temp; while (fast.Next != null && fast.Next.Next != null)//当快指针与慢指针相遇时 { fast = fast.Next.Next; slow = slow.Next