457. 环形数组是否存在循环 力扣（中等） 快慢指针，理解较难

457. 环形数组是否存在循环

存在一个不含 0 的 环形 数组 nums ，每个 nums[i] 都表示位于下标 i 的角色应该向前或向后移动的下标个数：

如果 nums[i] 是正数，向前 移动 nums[i] 步
如果 nums[i] 是负数，向后 移动 nums[i] 步
因为数组是 环形 的，所以可以假设从最后一个元素向前移动一步会到达第一个元素，而第一个元素向后移动一步会到达最后一个元素。

数组中的 循环 由长度为 k 的下标序列 seq ：

• 遵循上述移动规则将导致重复下标序列 seq[0] -> seq[1] -> ... -> seq[k - 1] -> seq[0] -> ...
• 所有 nums[seq[j]] 应当不是 全正 就是 全负
• k > 1

如果 nums 中存在循环，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [2,-1,1,2,2]
输出：true
解释：存在循环，按下标 0 -> 2 -> 3 -> 0 。循环长度为 3 。

题解：

https://leetcode-cn.com/problems/circular-array-loop/solution/fu-xue-ming-zhu-dong-hua-ti-jie-kuai-man-ju4g/

当 nums[id]<0 时 (id+nums[id]+(abs(nums[id])/n*n)+n)%n;

当 nums[id]>0 时 (id+nums[id])%n;

可优化成：  ((id+nums[id])%n+n)%n

只想到了模拟的方法。但其实可以优化空间，只要发现一直next的长度超过n，说明已经存在环

但是存在环，有可能是自环，需要判断 id?=nextid

代码：

// 非常暴力的解决方法了！！！！，虽然过了，但是不够优， 时间复杂度：O(n^2) 空间复杂度O(n)
class Solution {
public:
    bool circularArrayLoop(vector<int>& nums) {
     int n=nums.size();
     for(int i=0;i<nums.size();i++)
     {
         set<int> s;
         int id=i;
         s.insert(id);
         if(nums[id]>0)
         {
            while(1)
            {
                if (nums[id]<0) break;
                int nextid=(id+nums[id])%n;
                if(s.count(nextid)>0) 
                {
                    if(s.size()>1 && id!=nextid) return true; 
                        else break;
                }  
                s.insert(nextid);
                id=nextid;
            }
         } else     
         {
             while(1)
             {
                if (nums[id]>0) break;
                int nextid=(id+nums[id]+(abs(nums[id])/n*n)+n)%n;
                if(s.count(nextid)>0) 
                {
                     if(s.size()>1 && id!=nextid) return true; 
                      else break;
                } 
                s.insert(nextid);
                id=nextid;
             }
         }
     }
     return false;
    }
};

执行结果：

执行用时：752 ms, 在所有 C++ 提交中击败了5.57%的用户

内存消耗：162.3 MB, 在所有 C++ 提交中击败了5.28%的用户

 

法二：快慢指针

启发题目：环形链表：https://www.cnblogs.com/stepping/p/15112362.html

//  空间复杂度O(1)， 但是时间复杂度应该不是O（n），无法理解那种在原数组上赋值为0的情况
class Solution {
public:
    
    bool circularArrayLoop(vector<int>& nums) {
        int n=nums.size();
        for(int i=0;i<n;i++)
        {
            int low=i;
            int fast=((low+nums[low])%n+n)%n;
            int nextfast=((fast+nums[fast])%n+n)%n;
            while(nums[i]*nums[fast]>0 && nums[i]*nums[nextfast]>0)  // 表示移动方向都相同，不判断low的原因是，判断fast和nextfast已经覆盖了整条路径。
            {
                if(low==fast)
                {
                    int nextlow=((low+nums[low])%n+n)%n;
                    if(low!=nextlow) return true;     // 表示环的长度不为1
                        else break;                   // 必须break，否则，长度为1的环，造成死循环
                } 
                fast=((fast+nums[fast])%n+n)%n;       // fast移动2步
                fast=((fast+nums[fast])%n+n)%n; 
                nextfast=((fast+nums[fast])%n+n)%n;
                low=((low+nums[low])%n+n)%n;          // low移动1步
            }
        }
        return false;
    }
};