https://leetcode.cn/problems/valid-palindrome-ii/
֤Ĵ||
 
class Solution {
public:
    bool is_loopstr(string& str)
    {
        int left = 0;
        int right = str.size()-1;

        while(left < right)
        {
            if(str[left] != str[right])
            {
                return false;
            }
            left++;
            right--;
        }

        return true;
    }

    bool validPalindrome(string s) {
        int left = 0;
        int right = s.size()-1;

        while(left < right)
        {
            if(s[left] == s[right])
            {
                left++;
                right--;
            }
            else
            {
                string tmp1(s.begin()+left,s.begin()+right); 
                string tmp2(s.begin()+left+1,s.begin()+right+1);
                
                return is_loopstr(tmp1) || is_loopstr(tmp2);
            }
        }

        return true;
    }
};



// class Solution {
// public:
//     bool is_loopstr(string& str)
//     {
//         int left = 0;
//         int right = str.size()-1;

//         while(left < right)
//         {
//             if(str[left] != str[right])
//             {
//                 return false;
//             }
//             left++;
//             right--;
//         }

//         return true;
//     }

//     bool validPalindrome(string s) {
//         if(is_loopstr(s))
//             return true;

//         for(int i = 0; i < s.size(); ++i)
//         {
//             string tmp = s;
//             tmp.erase(tmp.begin()+i);
//             if(is_loopstr(tmp))
//             {
//                 return true;
//             }
//         }

//         return false;
//     }
// };

-----------------------------------------------------------------------------------

https://leetcode.cn/problems/linked-list-cycle-ii/submissions/584530411/?envType=problem-list-v2&envId=two-pointers
|| 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_map<ListNode*,int> counter;

        ListNode* cur = head;
        while(cur)
        {
            counter[cur]++;
            if(counter[cur] == 2)
                return cur;

            cur = cur->next;
        }

        return nullptr;
    }
};