Valid parenthesis in O(n) space and O(1) space

/*
Time complexity O(n), Space complexity O(1)
*/
// bool valid(string s)
// {
//     map<char,char> mp;
//     mp['(']=')';
//     mp['{']='}';
//     mp['[']=']';
//     stack<char> st;
//     for(auto itr:s){
//         if(itr=='(' || itr=='[' || itr=='{') st.push(itr);
//         else{
//             if(st.empty()){return false; }
//             char temp=st.top();
//             st.pop();
//             if(mp[temp]!=itr) return false;
//         }
//     }
//     if(st.empty()) return true;
//     return false;
// }

/*
TC. O(n^3) S.C=O(1)
Let's assume there is an opening bracket at ith index,and closing bracket for that bracket is at j so between i to j exclusive,
every starting index must have their closing bracket in i to j exclusive.
*/

int findclose(string str, int start,
                int end, char open, char close)
{
    int c = 1;
    int i = start + 1;
    while (i <= end) {
        if (str[i] == open)
            c++;
        else if (str[i] == close)
            c--;
        if (c == 0)
            return i;
        i++;
    }
    return i;
}

// Function1 to match opening bracket
int findopen(string str, int start,
                    int end, char open, char close)
{
    int c = -1;
    int i = end - 1;

    while (i >= start) {
        if (str[i] == open)
            c++;
        else if (str[i] == close)
            c--;
        if (c == 0)
            return i;
        i--;
    }
    return -1;
}
bool valid(string s){
    int i, j, k, x, start, end,n=s.size();

    for (i = 0; i < n; i++) {  //handling case of opening parenthesis
        if (s[i] == '(')
            j = findclose(s, i, n - 1, '(', ')');
        else if (s[i] == '{')
            j = findclose(s, i, n - 1, '{', '}');
        else if (s[i] == '[')
            j = findclose(s, i, n - 1, '[', ']');

        else {   // Handling case of closing parentheses
            if (s[i] == ')')
                j = findopen(s, 0, i, '(', ')');
            else if (s[i] == '}')
                j = findopen(s, 0, i, '{', '}');
            else if (s[i] == ']')
                j = findopen(s, 0, i, '[', ']');

            if (j < 0)  //for closing bracket,opening bracket must exist
                return false;

            continue;  //no need to check interval for closing bracket,it would have been already checked
                       //when opening bracket would have appeared for current closing bracket.
        }
        if (j >= n)  //for opening bracket,closing bracket must exist
            return false;

        int l = i,r = j;
        for (k = l + 1; k < r; k++) {  // if found, now check for each opening and closing parentheses in this interval
            if (s[k] == '(') {
                x = findclose(s, k, r, '(', ')');  //find closing bracket for opening bracket
                if (!(x < r)) {   //closing bracket must be before
                    return false;
                }
            }
            else if (s[k] == ')') {
                x = findopen(s, l, k, '(', ')');  //find opening bracket for closing bracket
                if (!(l < x)) {    //opening bracket must be after start
                    return false;
                }
            }

            if (s[k] == '{') {
                x = findclose(s, k, r, '{', '}');
                if (!(x < r)) {
                    return false;
                }
            }

            else if (s[k] == '}') {
                x = findopen(s, l, k, '{', '}');
                if (!(l < x)) {
                    return false;
                }
            }
            if (s[k] == '[') {
                x = findclose(s, k, r, '[', ']');
                if (!(x < r)) {
                    return false;
                }
            }
            else if (s[k] == ']') {
                x = findopen(s, l, k, '[', ']');
                if (!(l < x)) {
                    return false;
                }
            }
        }
    }
    return true;
}