leetcode刷题笔录1

1. 回文分割

• 给定一个字符串s，将s分割为数个子串，每个子串都是回文。
  比如，给定字符串"aab"，返回：
  

  [
      ["aa","b"],
      ["a","a","b"]   
  ]

• 思路：递归法，子串 s[i]...s[j] 的所有回文分割，都是由 s[1] 单独构成的一个元素的子串连接上 s[2]...s[j] 的所有回文分割（子问题），以及任何一个回文子串 s[1]...s[k] 连接上上 s[k+1]...s[j] 的回文分割（子问题）。
• 实现：
  

  class Solution {
  public:
      vector<vector<string>> partition(string s);
  private:
      vector<vector<string>> _partition(const string& s, const int i, const int j);
      vector<string> addhead(const vector<string>& list, const string& head);
      bool isPal(const string& s, const int i, const int j);
      vector<vector<int>> pals;
  };
  
  vector<vector<string>> Solution::partition(string s) {
      int n = s.size();
      pals = vector<vector<int>>(n, vector<int>(n, 0));
      return _partition(s, 0, n-1);
  }
  
  vector<vector<string>> Solution:: _partition(const string& s, const int i, const int j){
      vector<vector<string>> list;
      if(i==j){
          string tmp(1, s[i]);
          list.push_back(vector<string>(1, tmp));
          return list;
      }
      for(int p=i; p<j; p++){
          if(isPal(s,i,p)){
              vector<vector<string>> _list = _partition(s, p+1, j);
              string _head = s.substr(i,p-i+1);
              for(int k=0; k<=_list.size()-1; k++){
                  vector<string> tmp = addhead(_list[k],_head);
                  list.push_back(tmp);
              }
          }
      }
      if(isPal(s,i,j)){
          list.push_back(vector<string>(1, s.substr(i,j-i+1)));
      }
      return list;
  }
  
  vector<string> Solution::addhead(const vector<string>& list, const string& head){
      vector<string> rs;
      rs.push_back(head);
      for(int i=0; i<=list.size()-1; i++){
          rs.push_back(list[i]);
      }
      return rs;
  }
  
  bool Solution::isPal(const string& s, const int i, const int j){             
      if(i>=j){
          return true;
      }
      if(pals[i][j]!=0){
          return pals[i][j]>0 ? true : false;
      }    
      if(s[i]==s[j]){
          bool _isPal = isPal(s, i+1, j-1);
          pals[i][j] = _isPal ? 1 : -1;
          return _isPal;
      }
      else{
          pals[i][j] = -1;
          return false;
      }
  }  

2. 回文分割2

• 给定一个字符串s，将s分割为数个子串，每个子串都是回文。
  返回将字符串回文分割最少分割次数。
  比如，给定字符串"aab"，返回1，因为分割["aa","b"]可由一个分割（逗号）生成。
• 思路：动态规划，维护两个二维表，分别表示子串 s[i]...s[j] 是否是回文，以及最少回文分割次数（如果子串本身是回文，这个域就是0）。子串的最小回文分割次数就是 s[i]...s[k] 和 s[k+1]...s[j] 的最小回文分割次数之和（两个子问题的和）加1，在区间[i,j]取一个k值使该结果最小。
• 实现：
  

  class Solution {
  public:
      int minCut(string s);
  
  private:
      int _minCut(const string& s, const int i, const int j);    
      bool isPal(const string& s, const int i, const int j);
      
      vector<vector<int>> mcTable;
      vector<vector<int>> isPalTable; // 1 for true, -1 for false, 0 for uncertain
  };
  
  int Solution::minCut(string s){
      int n = s.size();
      mcTable = vector<vector<int>>(n, vector<int>(n,-1));
      isPalTable = vector<vector<int>>(n, vector<int>(n, 0));
      return _minCut(s, 0, n-1);
  }
  
  int Solution::_minCut(const string& s, 
                          const int i, 
                          const int j){
                      
      if(mcTable[i][j] != -1){
          return mcTable[i][j];
      }
      else{
          if(isPal(s,i,j)){
              mcTable[i][j]=0;
              return 0;
          }
          else{
              int min = INT_MAX;
              for(int k=i; k<=j-1; k++){
                  int cutNums = _minCut(s,i,k) + _minCut(s,k+1,j) + 1;
                  if(cutNums<min){
                      min = cutNums;
                  }
              }
              mcTable[i][j]=min;
              return min;
          }
      }
  }
  
  bool Solution::isPal(const string& s,
                          const int i, 
                          const int j){
                              
      if(i>=j){
          return true;
      }
      if(isPalTable[i][j] != 0){
          return isPalTable[i][j]>0 ? true : false;
      }
      else{
          if(s[i]!=s[j]){
              isPalTable[i][j]=-1;
              return false;
          }
          else{
              if(isPal(s,i+1,j-1)){
                  isPalTable[i][j]=1;
                  return true;
              }
              else{
                  isPalTable[i][j]=-1;
                  return false;
              }
          }
      }
  }

3. 围棋

• 给定一块二维棋盘，每一个格子要么是'X'要么是'O'。将所有被'X'围起来（像围棋一样围起来）'O'，都转变为'O'。
  比如，给定：
  

  X X X X
  X O O X
  X X O X
  X O X X

  返回：
  

  X X X X
  X X X X
  X X X X
  X O X X

• 思路：四条边上的'O'是不会被围起来的，与他们相邻的'O'也不会被围起来。该性质可以传递下去，类似于“感染”。那么就将四边上的'O'感染为'A'，再递归地感染相邻的'O'，完成之后将未被感染的'O'转为'X'，再将'A'转为'O'。
• 实现：
  

  class Solution {
  public:
      void solve(vector<vector<char>> &board);
  private:
      void infect(vector<vector<char>>& board, int i, int j);
  };
  
  void Solution::solve(vector<vector<char>> &board) {
      int n = board.size();
      if(n==0){
          return;
      }
      int m = board[0].size();
      for (int i=0; i<=n-1; i++){
          if (board[i][0]=='O'){
              infect(board, i, 0);
          }
          if (board[i][m-1]=='O'){
              infect(board, i, m-1);
          }
      }
      for (int j=0; j<=m-1; j++){
          if (board[0][j]=='O'){
              infect(board, 0, j);
          }
          if (board[n-1][j]=='O'){
              infect(board, n-1, j);
          }
      }
  
      for (int i=0; i<=n-1; i++){
          for (int j=0; j<=m-1; j++){
              if (board[i][j]=='O'){
                  board[i][j]='X';
              }
          }
      }
  
      for (int i=0; i<=n-1; i++){
          for (int j=0; j<=m-1; j++){
              if (board[i][j]=='A'){
                  board[i][j]='O';
              }
          }
      }
  }
  
  void Solution::infect(vector<vector<char>>& board, int i, int j){
      board[i][j] = 'A';
      int n = board.size();
      int m = board[0].size();
      if(i!=0 && board[i-1][j]=='O'){
          infect(board, i-1, j);
      }
      if(i!=n-1 && board[i+1][j]=='O'){
          infect(board, i+1, j);
      }
      if(j!=0 && board[i][j-1]=='O'){
          infect(board, i, j-1);
      }
      if(j!=m-1 && board[i][j+1]=='O'){
          infect(board, i, j+1);
      }
  }

4. “根-叶”数之和

• 给定一个二叉树，每个树的节点值都为 0~9 的整数。每一个从根节点到叶节点的路径代表一个整数。
  比如，路径 1-2-3 代表整数 123。找到二叉树所有从根节点到叶节点的路径的“根-叶”数之和。
  比如，给定：
  

      1
     / \
    2   3

   1-2路径表示12，1-3路径表示13，那么应当返回12+13=25。

• 思路：进入每一棵子树时，传入一个从根节点开始累积的值，到达叶节点后将改值加到全局变量sum上，如路径 1-2-3 ： 1-(1)-2-(12)-3(123)-sum+=123。这样就仍可以自然地进行递归迭代，而不用写二叉树的迭代遍历。
• 实现：
  

  /**
   * Definition for binary tree
   * struct TreeNode {
   *     int val;
   *     TreeNode *left;
   *     TreeNode *right;
   *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
   * };
   */
  class Solution {
  public:
      int sumNumbers(TreeNode *root) {
          sum = 0;
          _sumNumbers(root, 0);
          return sum;
      }
  private:
      void _sumNumbers(TreeNode* root, int rootVal){
          if (root==NULL){
              return;
          }
          int val = rootVal*10+root->val;
          if (root->left==NULL && root->right==NULL){
              sum += val;
          }
          _sumNumbers(root->left, val);
          _sumNumbers(root->right, val);
      }
      int sum;
  }; 

5. 最长连续序列

• 给定一个未排序的整数数组，找到最长连续序列的长度。
  比如，给定[100,4,200,1,3,2]，应当返回4，因为最长连续序列为[1,2,3,4]，其长度为4。
  算法的时间代价应当为O(n)。
• 思路：规定了O(n)的时间复杂度，想到使用哈希表。使用哈希集合st来滤掉重复的元素，哈希表mp中维护着这样的结构：所有已考虑的元素组成的连续序列的两端，键为两端的位置，值为另一端的位置。如果序列仅有一个元素（如考虑第一个元素时），则两端都是它自身，它的值指向它自己。由于st的帮助，所有新考虑的值都不会出现在连续序列中。
• 实现：
  

  class Solution {
  public:
      int longestConsecutive(vector<int> &num) {
          hash_map<int, int> mp;
          hash_set<int> st;
          int max = 0;
          for (int i=0; i<=num.size()-1; i++){
              if (st.find(num[i])!=st.end()){
                  continue;
              }
              st.insert(num[i]);
              int tleft = num[i];
              int tright = num[i];
              if (mp.find(tleft-1)!=mp.end()){
                  tleft = mp[tleft-1];
              }
              if (mp.find(tright+1)!=mp.end()){
                  tright = mp[tright+1];
              }
              int len = tright-tleft+1;
              max = max<len ? len : max;
              mp[tleft] = tright;
              mp[tright] = tleft;
          }
          return max;
      }
  };