Leetcode--Java--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 。
示例 2：

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

思路

1. 图的遍历标记。 由题意，将每个下标看做“点”，「当前点」和「当前点所能到达的下一个点」看作“边”。将问题转换为经典的「图论寻环」问题，同时又因为每个点出度固定为 1，并且规定「循环」必然是「同向」才合法，因此如果在遍历过程中发现存在反向，就停止检查。
2. 对于负数，可以转化为正向的取模结果
   ((cur + nums[cur]) % n + n) % n;
3. 迭代时，注意更新下一轮的cur
4. 符合不同的判断方法，可以先假设为正，在来进行判断是否符号相异，正负或者负正
5. 注意不要漏掉自环的判断。

进阶： O（1） 使用原数组标记

1. 如果访问过，就将这个值变成 Offset + i，i同时记录本轮的轮次
2. 如果大于Offset说明标记过，则跳出while 去判断是否等于tag

代码

class Solution {
    public boolean circularArrayLoop(int[] nums) {
       int n = nums.length;
       int vis[] = new int[n];//标记数组，标记是否出现过，同时记录所在轮次idx
       //start记录本轮开始的下标，idx记录本轮的轮次
        for (int start = 0, idx = 1; start < n; start ++, idx ++) {
           if (vis[start] != 0) continue; //已经标记过，就直接跳过，找下一个开始下标
           int cur = start; //cur记录当前下标，因为要修改，不能直接用start
           //假设当前符号为正
           boolean flag = nums[cur] > 0;
           //进行寻找环，不确定走多少，先设置不断循环
           while (true) {
              //下一个位置， 考虑到负数，进行+n再二次取模，保证偏移为正
             int next = ((cur + nums[cur]) % n + n) % n;
             if (next == cur) break; //自环，直接排除
             if (vis[next] != 0) {
                   //如果标记过，并且是本轮标记的  
                  if (vis[next] == idx) {
                    return true;
                  }    
                  //不是本轮标记，再往后走也不会有环
                  else break;
             }
             //排除符号不同的情况
              if (flag && nums[next] < 0) break;
              if (!flag && nums[next] > 0) break;
             //标记，并且更新cur准备下一轮迭代寻找
           vis[next] = idx;
           cur = next;
           }
        }
        return false;
    }
}

进阶：

class Solution {
    public boolean circularArrayLoop(int[] nums) {
       int n = nums.length;
       int OFFSET = 1010;  
       for (int i = 0; i < n; i ++ ) {
           if (nums[i] >= OFFSET) continue;
           int cur = i, tag = OFFSET + i;
           boolean selfLoop = false;
           boolean flag = nums[cur] > 0;
           while (true) {
               int next = ((cur + nums[cur]) % n + n) % n;
               if (next == cur) {
                   selfLoop = true;
                   break;
               }
              nums[cur] = tag;
              //这里要提前更新为 next  因为判断是基于next的
              cur = next;
              if (nums[cur] >= OFFSET) break;
              if (flag && nums[cur] < 0) break;
              if (!flag && nums[cur] > 0) break;
           }
           //不自环，并且访问的标记等于本轮  
           while (!selfLoop && nums[cur] == tag) return true;
       }
       return false;
    }
}