<p>You are given an integer array <code>nums</code> of length <code>n</code> where <code>nums</code> is a permutation of the numbers in the range <code>[0, n - 1]</code>.</p>

<p>You should build a set <code>s[k] = {nums[k], nums[nums[k]], nums[nums[nums[k]]], ... }</code> subjected to the following rule:</p>

<ul>
	<li>The first element in <code>s[k]</code> starts with the selection of the element <code>nums[k]</code> of <code>index = k</code>.</li>
	<li>The next element in <code>s[k]</code> should be <code>nums[nums[k]]</code>, and then <code>nums[nums[nums[k]]]</code>, and so on.</li>
	<li>We stop adding right before a duplicate element occurs in <code>s[k]</code>.</li>
</ul>

<p>Return <em>the longest length of a set</em> <code>s[k]</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [5,4,0,3,1,6,2]
<strong>Output:</strong> 4
<strong>Explanation:</strong> 
nums[0] = 5, nums[1] = 4, nums[2] = 0, nums[3] = 3, nums[4] = 1, nums[5] = 6, nums[6] = 2.
One of the longest sets s[k]:
s[0] = {nums[0], nums[5], nums[6], nums[2]} = {5, 6, 2, 0}
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [0,1,2]
<strong>Output:</strong> 1
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>0 &lt;= nums[i] &lt; nums.length</code></li>
	<li>All the values of <code>nums</code> are <strong>unique</strong>.</li>
</ul>

class Solution {
public:
    int makeRecursiveCalls(vector<bool>& visited, vector<int>& nums,
                           int k) {
        // cout << "inside makeRecursive calls" << endl;
        // check weather we are revisiting a number or not
        // auto it = find(visited.begin(), visited.end(), nums[k]);
        // means we found revisited lement and we have to stop here
        // if (it != visited.end()) {
        //     // couat << "base case hit!" << endl;
        //     return count;
        // }
             //or

         if (visited[k]) {
            return 0;
        }
        // mark value as visited
        // visited.push_back(nums[k]);
                 //or
       visited[k] = true;

        // otherwise make nested recursive calls
        // count = makeRecursiveCalls(visited, count, nums, nums[k]);
        // at last stack it gives me 0
        // return count + 1;
            //or
        return 1 + makeRecursiveCalls(visited, nums, nums[k]);
    }
    int arrayNesting(vector<int>& nums) {
        // vector<int> visited;
         vector<bool> visited(nums.size(), false);
        int maxCount = 0;
        // int count=0;
        for (int k = 0; k < nums.size(); k++) {
            // try for finding values for each k and return most nearest max
            // values
            // cout << "sending call for k value" << k << endl;
            if(!visited[k]){
               int count = makeRecursiveCalls(visited, nums, k);
               maxCount = max(maxCount, count); 
            }
                        //or
            // clear vector for next k assunotion
            // visited.clear();
            // supposing maxCount giving us count for k assumption
            // if (count > maxCount) {
            //     maxCount = count;
            // }
            //make count 0
            // count=0;
        }

        return maxCount;
    }
};
122251