leetcode刷题笔录2

6.字梯游戏

• 给定两个单词start和end，以及一本字典，找到由start到end的最短变换路径，每一次变换只允许改变一个字母，且变换后的单词必须出现在字典中。比如给出start为"hit"而end为"cog"，字典为["hot","dot","dog","lot","log"]，那么应当返回5，因为最短路径是："hit" -> "hot" -> "dot" -> "dog" -> "cog"
• 思路：函数参数中unordered_set类型参数说明字典是用散列表维护的。题目就是图论中最短路径算法的简单应用，同样使用散列表为词典中的每一个单词维护一个域m_ladderLens，记录与start顶点的距离（即变换的次数）：具体的，对某个顶点，遍历所有存在于字典中的变换（邻接顶点），挑选出m_ladderLens值小于顶点自己的m_ladderLens值+1的，对这些顶点重复该过程。
• 实现：
  

  class Solution {
  public:
      int ladderLength(string start, string end, unordered_set<string> &dict) {
          m_wordLen = start.length();
          for (unordered_set<string>::iterator i=dict.begin(); i!=dict.end(); i++){
              m_ladderLens[*i]=INT_MAX;
          }
          m_ladderLens[start]=1;        
  
          _ladderLength(start, end, dict);
  
          if (m_ladderLens[end] == INT_MAX){
              m_ladderLens[end] = 0;
          }
          return m_ladderLens[end];
      }
  private:
      void _ladderLength(string start, string end, unordered_set<string> &dict){
          for (int i=0; i<=m_wordLen-1; i++){
              for (int j=0; j<=26-1; j++){
                  string s = start;
                  s[i] = 'a'+j;
                  if (s!=start && 
                      dict.find(s)!=dict.end() && 
                      m_ladderLens[s]>m_ladderLens[start]+1)
                  {
                      m_ladderLens[s] = m_ladderLens[start]+1;
                      if (s != end){
                          _ladderLength(s, end, dict);
                      }
                  }
              }
          }
      }
      int m_wordLen;
      unordered_map<string, int> m_ladderLens;
  }; 

7.字梯游戏2

• 给定两个单词start和end，以及一本字典，找到由start到end的最短变换路径，每一次变换只允许改变一个字母，且变换后的单词必须出现在字典中。但是需要输出所有最短的路径（即使有多条，也要一起输出）。比如给出start为"hit"而end为"cog"，字典为["hot","dot","dog","lot","log"]，那么需要输出：
  

  [
      ["hit","hot","dot","dog","cog"],
      ["hit","hot","lot","log","cog"]
  ]

• 思路：与6几乎一致，但是输出不一样，需要在迭代过程中添加一个量currentLadders，对某个顶点，记录从start点到该点的最短路径。（如果有多条最短的路径，此时currentLadders中只有一条，它表示迭代到该函数的过程中产生的那一条。）
• 实现：
  

  class Solution {
  public:
      vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
          m_ladders = vector<vector<string>>();
          m_wordLen = start.size();
          for (unordered_set<string>::iterator i=dict.begin(); i!=dict.end();i++){
              m_ladderLens[*i]=INT_MAX;
          }
          m_ladderLens[start] = 1;
  
          _ladderLength(start, end, dict);
          shortestLen = m_ladderLens[end]==INT_MAX ? 0 : m_ladderLens[end];
          _findLadders(start, end, vector<string>(), dict);
  
          return m_ladders;
      }
  
  private:
      void _findLadders(const string& start, const string& end, vector<string> currentLadders, unordered_set<string>& dict){
          currentLadders.push_back(start);
          if (start==end && currentLadders.size()==shortestLen){
              m_ladders.push_back(currentLadders);
              return;
          }
          for (int i=0; i<=m_wordLen-1; i++){
              for (int j=0; j<=26-1; j++){
                  string s = start;
                  s[i] = 'a'+j;
  
                  if (s!=start && dict.find(s)!=dict.end() && m_ladderLens[s]>=m_ladderLens[start]+1){
                      m_ladderLens[s]=m_ladderLens[start]+1;
                      _findLadders(s, end, currentLadders, dict);
                  }
              }
          }
      }
  
      void _ladderLength(string start, string end, unordered_set<string> &dict){
          for (int i=0; i<=m_wordLen-1; i++){
              for (int j=0; j<=26-1; j++){
                  string s = start;
                  s[i] = 'a'+j;
                  if (s!=start && 
                      dict.find(s)!=dict.end() && 
                      m_ladderLens[s]>m_ladderLens[start]+1){
                      m_ladderLens[s] = m_ladderLens[start]+1;
                      if (s != end){
                          _ladderLength(s, end, dict);
                      }
                  }
              }
          }
      }    
      int m_wordLen;
      unordered_map<string, int> m_ladderLens;
      int shortestLen;
      vector<vector<string>> m_ladders;    
  }; 

8.回文验证

• 给定一个字符串，判断其是否是回文，只考虑数字和字母部分，标点符号略去。同样，大小写一致的字母也认为是一样的。比如字符串"A man, a plan, a canal: Panama"就是回文，而
"race a car"则不是回文。
  
• 思路：很简单。
• 实现：
  

  class Solution {
  public:
      bool isPalindrome(string s){
          for (int i=0, j=s.size()-1; i<=j; ){
              if (!isAlphanumeric(s[i])){
                  i++;
                  continue;
              }
              if (!isAlphanumeric(s[j])){
                  j--;
                  continue;
              }
              if (tolower(s[i])==tolower(s[j])){
                  i++;
                  j--;
                  continue;
              }
              return false;
          }
          return true;
      }
  private:
      bool isAlphanumeric(char c){
          if (c>='a' && c<='z'){return true;}
          if (c>='A' && c<='Z'){return true;}
          if (c>='1' && c<='9'){return true;}
          if (c=='0'){return true;}
          return false;
      }
  }; 

 9.二叉树最大路径和

• 给出一棵最大二叉树，找到其“最大路径和”。一条路径，可以从二叉树的任何一个节点开始，并到任何一个节点结束。路径和就是这一条路径上所有节点的值的和。需要考虑负数节点。比如，给出这样一棵二叉树：
  

         1
        / \
       2   3

   需要返回6，因为路径2-3-1的路径和为6（2+3+1）。

• 思路：这个题的陷阱是，可能出现负数值的节点，我已开始就漏考虑了，而认为最大路径至少有一个端点是叶子节点，另一个端点是根节点或叶子节点。可能有负数值的节点的情况下，这样考虑：
  • 为每个节点考虑两个属性，最大路径和（即要求的，记为S）和有一个端点为根节点的最大路径和（记为P）。
  • 某个节点的S是以下这几个值当中最大的：
    • 左节点的S（如果左节点存在的话）
    • 右节点的S（如果右节点存在的话）
    • 左节点的P（如果左节点存在且P>0，否则算0，就当没取它，以根节点为一个端点）+右节点的P（同左节点，若两者都不去，就是根节点一个端点组成的路径）+节点自身的值
  • 某个节点的P是以下这几个值中最大的：
    • 左节点的P（如果左节点存在且P>0，否则算0，就当没取它，仅有根节点一个节点组成的路径）+节点自身的值
    • 右节点的P（同上）+节点自身值
• 实现：
  

  /**
   * 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 maxPathSum(TreeNode *root) {
          int sum = INT_MIN;
          if (root->left != NULL){
              int sum_left = maxPathSum(root->left);
              sum = max(sum, sum_left);
          }
          if (root->right != NULL){
              int sum_right = maxPathSum(root->right);
              sum = max(sum, sum_right);
          }
          int sum_root = (root->left==NULL?0:max(0,maxPathSumToRoot(root->left))) + 
                          root->val + 
                         (root->right==NULL?0:max(0,maxPathSumToRoot(root->right)));
          sum = max(sum, sum_root);
          return sum;        
      }
  private:
      int maxPathSumToRoot(TreeNode *root){        
          int sum = INT_MIN;
          if (root->left != NULL){
              int sum_left = root->val + max(0, maxPathSumToRoot(root->left));
              sum = max(sum, sum_left);
          }
          if (root->right != NULL){
              int sum_right = root->val + max(0, maxPathSumToRoot(root->right));
              sum = max(sum, sum_right);
          }
          sum = max(sum, root->val);
          return sum;
      }
  };

10.股价

• 给定一个数组prices，表示第 i 天的股价，你总共只能买入并卖出1股，请确定买入和卖出的时机，使收益最大。
• 思路：简单，从前向后遍历数组，维护一个域记录已遍历的天数中股价最低的那一天，然后用那一天的股价减去股价最低的那天的股价，获得一个收益。取最大的收益。
• 实现：
  

  class Solution {
  public:
      int maxProfit(vector<int> &prices) {
          int minIndex = 0;
          int maxProfitValue = 0;
          for (int i=0; i<=int(prices.size())-1; i++)
          {
              if (prices[i]<prices[minIndex])
              {
                  minIndex = i;
              }
              int profit = prices[i]-prices[minIndex];
              maxProfitValue = maxProfitValue<profit ? profit : maxProfitValue;
          }
          return maxProfitValue;
      }
  }; 

11.股价2

• 给定一个数组prices，表示第 i 天的股价，你每天都可以进行一次交易（买入或卖出一股），请确定买入和卖出的时机，使收益最大。
• 思路：简单，直观地看，如果第 i 天的股价低于第 i+1 天，那么就在第 i 天买进，第 i+1天卖出。
• 实现：
  

  class Solution {
  public:
      int maxProfit(vector<int> &prices) {
          int maxProfitValue = 0;
          for (int i=0; i<=int(prices.size())-2; i++){
              if (prices[i]<prices[i+1]){
                  maxProfitValue+=prices[i+1]-prices[i];
              }
          }
          return maxProfitValue;
      }
  }; 

12.股价3

• 给定一个数组prices，表示第 i 天的股价，你只能依次进行两次交易（买入-卖出-买入-卖出），请确定买入和卖出的时机，使收益最大。
• 思路：一开始的想法是，把10中的代码拿过来稍作修改，然后将数组分割成[0...i]和[i...n-1]两个部分，最大收益就是两个部分最大收益之和（每个部分进行一次交易）。遍历 i 找出最大的。但是这样太耗时间了，后来看到uniEagle提供的思路，才恍然大悟。其实10中找出一段时间[i...j]内最大收益的过程就已经解决了[i...k]的子问题，只要维护两个一维数组，一个记录[0...i]的最大收益，一个记录[i...n-1]的最大收益即可。这两个数组都是可以在一次遍历中得出的。然后再考虑两个部分收益之和。
• 实现：
  

  class Solution {
  public:
      int maxProfit(vector<int> &prices) {
          vector<int> profitToEnd(prices.size(), 0);
          {
              int minIndex = 0;
              int maxPft = 0;
              for (int i=0; i<prices.size(); i++){
                  int tmpPft = prices[i]-prices[minIndex];
                  if (tmpPft > maxPft){
                      maxPft = tmpPft;
                  }
                  if (prices[i]<prices[minIndex]){
                      minIndex = i;
                  }
                  profitToEnd[i]=maxPft;
              }
          }
          vector<int> profitFromStart(prices.size(), 0);
          {
              int maxIndex = prices.size()-1;
              int maxPft = 0;
              for(int i=prices.size()-1; i>=0; i--){
                  int tmpPft = prices[maxIndex]-prices[i];
                  if (tmpPft > maxPft){
                      maxPft = tmpPft;
                  }
                  if (prices[maxIndex] < prices[i]){
                      maxIndex = i;
                  }
                  profitFromStart[i]=maxPft;
              }
          }
          int maxPft = 0;
          for (int i=0; i<prices.size(); i++)
          {
              int tmpPft = profitFromStart[i]+profitToEnd[i];
              if (maxPft<tmpPft){
                  maxPft = tmpPft;
              }
          }
          return maxPft;
      }
  };