题目描述

存在一个不含 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 。

示例 2：

输入：nums = [-1,2]
输出：false
解释：按下标 1 -> 1 -> 1 ... 的运动无法构成循环，因为循环的长度为 1 。根据定义，循环的长度必须大于 1 。

示例 3:

输入：nums = [-2,1,-1,-2,-2]
输出：false
解释：按下标 1 -> 2 -> 1 -> ... 的运动无法构成循环，因为 nums[1] 是正数，而 nums[2] 是负数。
所有 nums[seq[j]] 应当不是全正就是全负。

提示：

    1 <= nums.length <= 5000
    -1000 <= nums[i] <= 1000
    nums[i] != 0

进阶：你能设计一个时间复杂度为 O(n) 且额外空间复杂度为 O(1) 的算法吗？

算法分析

解题思路

    求环怎么少得了快慢指针，思路如下：

    从不同的起点即（0~n-1）来开始
    设置一个slow和fast指针，满足符号均为正数或负数（可以考虑相乘>0）循环直到slow和fast相等，或者不满足条件

    更多细节

    如何计算下一个位置：考虑到可能是负数，也可能大于n，这里采用 (((nums[i]+i)%n)+n)%n保证是一个有效的范围在 0~n-1里
    如何避免重复遍历：
        条件里假设不存在0，那么只要设置nums[i]=0来表示已被遍历，后续就可以忽略
        每次遍历设置设置需要后置，避免对一些判断产生的影响
    判断长度是否为1： 只要把slow和fast->next比较即可判断，那么说明是长度为1的环，说明不满足题目要求

代码

class Solution {
public:
    bool circularArrayLoop(vector<int>& nums) {
        int n=nums.size();

        auto nxt=[nums,n](int cur){
            return ((cur+nums[cur])%n+n)%n;
        };

        for(int i=0;i<n;++i){
            if(!nums[i]) continue;
            int slow=i,fast=nxt(i);
            while(nums[i]*nums[fast]>0 && nums[i]*nums[nxt(fast)]>0){
                if(slow==fast){
                    if(slow!=nxt(slow)) return true;
                    break;
                }
                slow=nxt(slow);
                fast=nxt(nxt(fast));
            }
            int dir=nums[i],p=i;
            while(dir*nums[p]>0){
                int np=nxt(p);
                nums[p]=0;
                p=np;
            }
        }
        return false;
    }
};

时间复杂度分析

时间复杂度：最坏的执行次数2n，所以，时间复杂度为O(n)。

空间复杂度：整个过程中只对原数组进行修改，空间复杂度为O(1)