Simplify Path & Word Search & Longest Valid Parentheses

(1) Simplify Path

用栈来做，先把输入字符串以'/'为分隔符分来，如果遇到'.'或者空输入什么都不做。如果遇到'..'就弹栈。然后每从栈里退出一个元素就用'/'连接起来，注意顺序。

class Solution {
private:
    string getWord(string path,int &i)
    {
        string tmp;
        while(path[i]!='/' && path[i]!='\0')
        {
            tmp.push_back(path[i]);
            i++;
        }
        return tmp;
    }

public:
    string simplifyPath(string path) {
        stack<string> stk;
        string ret;
        vector<string> list; 
        
        for(int i=0;i<path.size();i++)
        {
            if(path[i]=='/')
                continue;
            string tmp=getWord(path,i);
            if(tmp==".")
                continue;
            else if(tmp=="..")
                {
                    if(!stk.empty())
                        stk.pop();
                }
            else
                stk.push(tmp);
        }
        
        if(stk.empty())
            return "/";
        while(!stk.empty())
        {
            ret="/"+stk.top()+ret;
            stk.pop();
        }
        
        return ret;
    }
};

测试输入集里居然有"/.../"这种sb东西!f**king stupid!!!

(2) Word Search 

dfs,注意回溯复位：

class Solution {
private:
    bool dfs(vector<vector<char> > &board,string word,int x,int y)
    {
        if(word.size()==0)
            return true;
        bool flag=false;
        
        if(x>=1 && board[x-1][y]==word[0])
        {
            board[x-1][y]='*';
            flag=dfs(board,word.substr(1),x-1,y);
            if(flag)
                return flag;
            else
                board[x-1][y]=word[0];
        }
        if(y>=1 && board[x][y-1]==word[0])
        {
            board[x][y-1]='*';
            flag=dfs(board,word.substr(1),x,y-1);
            if(flag)
                return flag;
            else
                board[x][y-1]=word[0];
        }
        if(x+1<board.size() && board[x+1][y]==word[0])
        {
            board[x+1][y]='*';
            flag=dfs(board,word.substr(1),x+1,y);
            if(flag)
                return flag;
            else
                board[x+1][y]=word[0];
        }
        if(y+1<board[0].size() && board[x][y+1]==word[0])
        {
            board[x][y+1]='*';
            flag=dfs(board,word.substr(1),x,y+1);
            if(flag)
                return flag;
            else
                board[x][y+1]=word[0];
        }
        return  flag;
    }

public:
    bool exist(vector<vector<char> > &board, string word) {
        if(word.size()==0)
            return true;
        int m=board.size(),n=board[0].size();
        
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
            {
                if(board[i][j]==word[0])
                {
                    board[i][j]='*';
                    if(dfs(board,word.substr(1),i,j))
                        return true;
                    board[i][j]=word[0];
                }
                    
            }
        return false;
    }
};

(3) Longest Valid Parentheses 

遍历S。遇到'('，放入lefts。如果遇到')'，如果lefts是空，说明这是一个无法匹配的')'，记录下last。last里面存放的其实是最后一个无法匹配的')'。为啥要保存这个值呢？主要是为了计算后面完整的表达式的长度。可以这样理解： “所有无法匹配的')'”的index其实都是各个group的分界点[1]。

class Solution {
public:
    int longestValidParentheses(string s) {
        int pre=-1,maxlen=0;
        if(s.size()==0)
            return maxlen;
        
        stack<int> stk;
        
        for(int i=0;i<s.size();i++)
        {
            if(s[i]=='(')
                stk.push(i);
            else
            {
                if(stk.empty())
                    pre=i;
                else
                {
                    stk.pop();
                    if(stk.empty())
                        maxlen=max(maxlen,i-pre);
                    else
                        maxlen=max(maxlen,i-stk.top());
                }
            }
        }
        return maxlen;
    }
};

参考：

[1] http://www.cnblogs.com/lichen782/p/leetcode_Longest_Valid_Parentheses.html