fast

Faster RCNN Fast-RCNN基本实现端对端（除了proposal阶段外），下一步自然就是要把proposal阶段也用CNN实现（放到GPU上）。这就出现了Faster-RCNN，一个完全end-to-end的CNN对象检测模型（现在是完全的端对端的网络了）。 论文提出：网络中的各个卷积层特征（feature map）也可以用来预测类别相关的region proposal（不需要事先执行诸如selective search之类的算法），但是如果简单的在前面增加一个专门提取proposal的网络又显得不够优雅，所以最终把region proposal提取和Fast-RCNN部分融合进了一个网络模型 (区域生成网络 RPN层)，虽然训练阶段仍然要分多步，但是检测阶段非常方便快捷，准确率也与原来的Fast-RCNN相差不多，从此，再也不用担心region proposal提取耗时比实际对象检测还多这种尴尬场景了。(faster RCNN可以大致看做“区域生成网络+fast RCNN“的系统，用区域生成网络代替fast RCNN中的Selective Search方法) 综上，我们可以看出Faster RCNN的创新点就是：将Region Proposal与Fast RCNN相结合，最终实现了速度与精度的平衡。 不信你看： Fast RCNN与Faster RCNNn对比如下：

Name of article：Flow-level State Transition as a New Switch Primitive for SDN Origin of the article：Moshref M , Bhargava A , Gupta A , et al. [ACM Press the 2014 ACM conference - Chicago, Illinois, USA (2014.08.17-2014.08.22)] Proceedings of the 2014 ACM conference on SIGCOMM - SIGCOMM \"14 - Flow-level state transition as a new switch primitive for SDN[J]. Acm Sigcomm Computer Communication Review, 2014:377-378. ABSTRACT： In software-defined networking, the controller installs flow-based rules at switches either proactively or reactively 在软件定义的网络中，控制器 主动或被动 地在交换机上安装 基于流的规则 。

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node index 1 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： 输入：head = [1,2], pos = 0 输出：tail connects to node index 0 解释：链表中有一个环，其尾部连接到第一个节点。 示例 3： 输入：head = [1], pos = -1 输出：no cycle 解释：链表中没有环。 进阶： 你是否可以不用额外空间解决此题？ idea :fast,slow从head出发步长分别为2和1，第一次相遇让slow不动，fast从head开始，步长都变为1，第二次相遇的地方即为入环的第一个节点 证明 假设非环部分的长度是x，从环起点到相遇点的长度是y。环的长度是c。 现在走的慢的那个指针走过的长度肯定是x+n1*c+y，走的快的那个指针的速度是走的慢的那个指针速度的两倍。这意味着走的快的那个指针走的长度是2(x+n1*c+y)。

第一种方法：直接遍历时，用hashset存放，判断是否存在环 第二种方法：使用快慢指针 public class CycleLinkedList { public static void main(String[] args) { Node head = new Node(1); Node node3 = new Node(3); head.next = node3; head.next.next = new Node(5); head.next.next.next = new Node(7); head.next.next.next.next = new Node(9); head.next.next.next.next.next = node3; System.out.println("是否有环：" + hasCycle(head)); Node enterNode = getEnterNode(head); System.out.println("环的入口：" + enterNode.value); System.out.println(getCycleSize(enterNode)); } // 环的长度 public static Integer getCycleSize(Node node) { Node start = node; int len = 1; while

fail-fast和fail-safe的区别： fail-safe允许在遍历的过程中对容器中的数据进行修改，而fail-fast则不允许。 fail-fast ( 快速失败 ) fail-fast:直接在容器上进行遍历，在遍历过程中，一旦发现容器中的数据被修改了，会立刻抛出ConcurrentModificationException异常导致遍历失败。java.util包下的集合类都是快速失败机制的, 常见的的使用fail-fast方式遍历的容器有HashMap和ArrayList等。 在使用迭代器遍历一个集合对象时,比如增强for,如果遍历过程中对集合对象的内容进行了修改(增删改),会抛出ConcurrentModificationException 异常. fail-fast的出现场景 在我们常见的java集合中就可能出现fail-fast机制,比如ArrayList，HashMap。在多线程和单线程环境下都有可能出现快速失败。 1、单线程环境下的fail-fast： ArrayList发生fail-fast例子： public static void main(String[] args) { List<String> list = new ArrayList<>(); for (int i = 0 ; i < 10 ; i++ ) { list.add(i + ""); }

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node index 1 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： 输入：head = [1,2], pos = 0 输出：tail connects to node index 0 解释：链表中有一个环，其尾部连接到第一个节点。 示例 3： 输入：head = [1], pos = -1 输出：no cycle 解释：链表中没有环。 解题思路： 构建双指针第一次相遇： 设两指针 fast，slow 指向链表头部 head，fast 每轮走 2 步，slow 每轮走 1 步； 若 fast 指针走过链表末端，说明链表无环，直接返回 null（因为每走 1轮，fast 与 slow 的间距 +1，若有环，快慢两指针终会相遇）； 当 fast == slow 时，代表两指针在环中 第一次相遇，此时执行 break 跳出迭代； 第一次相遇时步数分析： 设链 表头部到环需要走 a 步 ， 链表环走一圈需要 b

# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def hasCycle(self, head): """ :type head: ListNode :rtype: bool """ if head==None: return False slow,fast=head,head.next if fast==None: return False while slow!=fast: if fast.next==None: return False elif fast.next.next==None: return False slow=slow.next fast=fast.next.next return True 还是双指针方法灵活 来源： https://blog.csdn.net/weixin_45569078/article/details/101036155

今天刷的另一道题是LeetCode第141题，环形链表，这儿题也不是很难，直接快慢指针就解决了，具体地代码如下： public boolean hasCycle(ListNode head) { ListNode fast=head; if (head==null){ return false; } if (head.next==head){ return true; } while (fast.next!=null){ if (fast.next.next==null){ return false; } fast=fast.next.next; head=head.next; if (fast==head){ return true; } } return false; } 来源： https://www.cnblogs.com/cquer-xjtuer-lys/p/11546065.html

题目： 给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环 输入： head = [3,2,0,-4], pos = 1 输出： true 解释： 链表中有一个环，其尾部连接到第二个节点 输入： head = [1], pos = -1 输出： false 解释： 链表中没有环。 这一题，最粗暴的解法，就是存在hash表里，依次遍历检查是否存在过; 很明细，需要额外的空间复杂度O(n); 其时间复杂度为O(n);因为只要遍历一边链表即可，查询是在O(1)范围之内的。 class Solution { public: bool hasCycle(ListNode *head) { if(!head) return false; unordered_map<ListNode *,int> hash; hash[head]=1; if(head->next) head=head->next; else return false; while(head) { if(hash.find(head)==hash.end()) hash[head]=1; else return true; head=head->next; } return false; } };

翻译： 摘要 近似最近邻搜索（ANNS）是数据库和数据挖掘的基础问题。一个可伸缩的ANNS算法应当在空间和时间上都很快。 来源： https://blog.csdn.net/pengchengliu/article/details/100939100