[DSA] training camp week-3

最新推荐文章于 2024-08-26 00:02:00 发布
最新推荐文章于 2024-08-26 00:02:00 发布
阅读量212 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mouliu6141/article/details/108332085
版权

2020/08/24-2020/08/31

完成情况

TitleKeywordsRounds
70. Climbing Stairsrecursion/LRU4/5
77. Combinationsrecursion/backtracking2/5
22. Generate-Parenthesesrecursion/backtracking3/5
17. Letter-Combinations-of-a-Phone-Numberrecursion/backtracking1/5
112. Path-Sumrecursion/backtracking1/5
113. Path-Sum-IIrecursion/backtracking2/5
46. Permutationsrecursion/backtracking1/5
78. Subsetsrecursion/backtracking1/5
98. Validate-Binary-Search-Treerecursion2/5
105. Construct-Binary-Tree-from-Preorder-and-Inorder-Traversalrecursion2/5
226. Invert-Binary-Treerecursion2/5
236. Lowest-Common-Ancestor-of-a-Binary-Treerecursion2/5
104. Maximum-Depth-of-Binary-Treerecursion2/5
111. Minimum-Depth-of-Binary-Treerecursion1/5
297. Serialize-and-Deserialize-Binary-Treerecursion1/5
50. Powrecursion/divide-conquer1/5

70. Climbing Stairs

class Solution {
 private:
  int helper(int n, vector<int> &vec) {
      if (n <= 3) return n;
      if (vec[n] > 0) {
          return vec[n];
      } else {
          vec[n] = helper(n - 1, vec) + helper(n - 2, vec);
      }
      return vec[n];
  }
 public:

  int climbStairs(int n) {
      vector<int> vec(n + 1, 0);
      return helper(n, vec);
  }
};

22. Generate Parentheses

class Solution {
 public:
  void help(int left , int right, int n, string s, vector<string>& result) {
      // recursion terminator
      if (left == n and right == n) {
          result.push_back(s);
          return;
      }
      if (left < n) {
        help(left + 1, right, n, s + "(", result);
      }
      if (right < left) {
          help(left, right + 1, n, s + ")", result);
      }
  }

  vector<string> generateParenthesis(int n) {
      vector<string> result;
       help(0, 0, n, "", result);
      return result;
  }
};

77. Combinations

class Solution {
 public:
  vector<vector<int> > combine(int n, int k) {
      vector<vector<int> > result;
      vector<int> vec;
      recurion(result, vec, 1, n, k);
      return result;
  }

  void recurion(vector<vector<int> > &result, vector<int> &vec, int i, int& n, int& k) {
      if (vec.size() >= k) {
          result.push_back(vec);
          return;
      }
      if (i > n) return;
      vec.push_back(i);
      recurion(result, vec, i + 1, n, k); // 选
      vec.pop_back();
      recurion(result, vec, i + 1, n, k); // 不选
  }
};

78. Subsets

// 利用递归去模拟每次放入和取出的操作, 即选还是不选
class Solution {
 public:
  vector<vector<int>> subsets(vector<int>& nums) {
      vector<vector<int>> result; 
      vector<int> item; 
      help(nums, 0, result, item);
      return result;
  }

  void help(vector<int>& nums, int i, vector<vector<int>>& res, vector<int>& item) {
      // recursion terminator
      if (i >= nums.size()) {
          res.push_back(item);
          return;
      }

      // drill down
      item.push_back(nums[i]);
      help(nums, i + 1, res, item); // 放入

      item.pop_back();
      help(nums, i + 1, res, item); // 不放入
  }
};

46. Permutations

class Solution {
 public:
  void help(vector<int> &nums, int begin, vector<vector<int>> &result) {
      if (begin >= nums.size()) {
          result.push_back(nums);
          return;
      }

      for (int i = begin; i < nums.size(); i++) {
          swap(nums[i], nums[begin]); // 前序
          help(nums, begin + 1, result);
          swap(nums[i], nums[begin]); // 后续
      }
  }

  vector<vector<int>> permute(vector<int> &nums) {
      vector<vector<int>> result;
      help(nums, 0, result);
      return result;
  }
};

17. Letter-Combinations-of-a-Phone-Number*

class Solution {
 public:
  void recurion(const string& str,
                string &digits,
                int i,
                vector<string> &result,
                unordered_map<char, string> &map) {
      // recurison terminator
      if (i == digits.size()) {
          result.push_back(str);
          return;
      }
      // process
      string letters = map[digits[i]];
      for (int j = 0; j < letters.size(); ++j) {
          // drill down
          recurion(str + letters[j], digits, i + 1, result, map);
      }
  }
  vector<string> letterCombinations(string digits) {
      vector<string> result;
      if (digits.empty()) return result;

      unordered_map<char, string> map;
      map.emplace('2', "abc");
      map.insert(make_pair('3', "def"));
      map.emplace('4', "ghi");
      map.emplace('5', "jkl");
      map.emplace('6', "mno");
      map.emplace('7', "pqrs");
      map.emplace('8', "tuv");
      map.emplace('9', "wxyz");
      recurion("", digits, 0, result, map);
      return result;
  }
};

112. Path-Sum

class Solution {
 private:
  bool preorder(TreeNode *node, int sum, int &val) {
      if (!node) return false;

      val += node->val;
      if (!node->left and !node->right and sum == val) {
          return true;
      }
      bool l = preorder(node->left, sum, val);
      bool r = preorder(node->right, sum, val);
      val -= node->val;
      return l or r; // 虽然node本身不是，但只要起左右子树中有一个满足，即为true
  }
 public:
  bool hasPathSum(TreeNode *root, int sum) {
      int val = 0;
      return preorder(root, sum, val);
  }
};

113. Path-Sum-II

class Solution {
 private:
  // 既然是树的递归，就一定会用到preorder/inorder/postorder.递归函数名直接体现递归顺序即可
  void preorder(TreeNode *node, int sum, int &val, vector<vector<int>> &result, vector<int> &path) {
      // recursion terminator
      if (!node) return; // 如果为null，即不进入这层梦境，不对参数进行任何的改变

      // process current level logic
      val += node->val;
      path.push_back(node->val);
      if (!node->left && !node->right && val == sum) {
          result.push_back(path);
      }
      // drill down
      preorder(node->left, sum, val, result, path);
      preorder(node->right, sum, val, result, path);

      // reverse states
      val -= node->val;
      path.pop_back();
  }

 public:
  vector<vector<int>> pathSum(TreeNode *root, int sum) {
      vector<vector<int>> result;
      vector<int> path;
      int val = 0;
      preorder(root, sum, val, result, path);
      return result;
  }
};

105. Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal

class Solution {
 public:
  TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
      return create(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);
  }

  TreeNode *create(vector<int> &preorder, vector<int> &inorder, int p_start, int p_end, int i_start, int i_end) {
      if (p_start > p_end) return nullptr;

      TreeNode *node = new TreeNode(preorder[p_start]); // 这是头结点
      int root_pos;
      for (int i = i_start; i < i_end; ++i) {
          if (inorder[i] == node->val) { // 如果中序的元素等于前序的元素，此时的索引i即为pos即为在中序中头结点的位置
              root_pos = i;
              break;
          }
      }
      node->left = create(preorder, inorder, p_start + 1, p_start + (root_pos - i_start), i_start + 0, root_pos - 1);
      node->right = create(preorder, inorder, p_end - (i_end - root_pos) + 1, p_end + 0, root_pos + 1, i_end + 0);
      return node;
  }
};

226. Invert-Binary-Tree

class Solution {
 public:
  TreeNode *invertTree(TreeNode *root) {
      if (!root) return root;
      swap(root->left, root->right);
      invertTree(root->left);
      invertTree(root->right);
      return root;
  }
};

236. Lowest-Common-Ancestor-of-a-Binary-Tree

// 个人认为第一种解法不具有通用性，虽然很精妙，但是无法解决一类问题
class Solution1 {
 public:
  TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
      // recurison terminator
      if (!root) return nullptr;
      if (root == p or root == q) return root;

      auto l = lowestCommonAncestor(root->left, p, q); // 如果不满足上述条件，继续遍历左子树
      auto r = lowestCommonAncestor(root->right, p, q);// 如果不满足上述条件，继续遍历右子树
      // 递归的返回值，是从最下层传上来的

      if (!l and !r) return nullptr;
      else if (l and !r) return l;
      else if (r and !l) return r;
      else return root;
  }
};

class Solution2 {
 public:
  TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
      vector<TreeNode *> path;
      vector<TreeNode *> result_p;
      vector<TreeNode *> result_q;
      preorder(root, p, path, result_p);
      path.clear();
      preorder(root, q, path, result_q);

      TreeNode *res = NULL;
      int len = result_p.size() > result_q.size() ? result_q.size() : result_p.size();
      for (int i = 0; i < len; i++) {
          if (result_p[i] == result_q[i]) {
              res = result_q[i]; // 相等就更新，不相等就退出循环
          }
      }
      return res;
  }

  void preorder(TreeNode *node, TreeNode *search, vector<TreeNode *> &path, vector<TreeNode *> &result) {
      if (!node) return;

      path.push_back(node);
      if (node->val == search->val) {
          result = path;
      }
      preorder(node->left, search, path, result);
      preorder(node->right, search, path, result); 
      path.pop_back();
  }
};

104. Maximum Depth of Binary Tree

class SolutionSimplify {
 public:
  int maxDepth(TreeNode *root) {
      if (!root) return 0;
      return max(maxDepth(root->left), maxDepth(root->right)) + 1;
  }
};

111. Minimum-Depth-of-Binary-Tree

class Solution {
 public:
  int minDepth(TreeNode *root) {
      if (!root) {
          return 0;
      }
      if (!root->left and !root->right) {
          return 1;
      }
      int l = minDepth(root->left) + 1;
      int r = minDepth(root->right) + 1;
      if (!root->right) {
          return l;
      } else if (!root->left) {
          return r;
      } else {
          return min(l, r);
      }
  }
};

50. Pow

class Solution {
public:
    double myPow(double x, int n) {
        if (n == 0) {
            return 1;
        }
        
        long N = n;
        if (N < 0) {
            N = -N;
        }
        double res = 1.0;
        for (int i = N; i != 0; i = i / 2) {
            if (i % 2) {
                res *= x;
            } 
            x *= x;
        }
        
        return n > 0 ? res : 1/res;
    }
};

297. Serialize-and-Deserialize-Binary-Tree

class Codec2 {
 public:

  // Encodes a tree to a single string.
  string serialize(TreeNode *root) {
      if (!root) return "#";

      // 相当于前序遍历
      string str = to_string(root->val) + ","
          + serialize(root->left) + ","
          + serialize(root->right);
      printf("%s\n", str.c_str());
      return str;
  }

  // Decodes your encoded data to tree.
  TreeNode *deserialize(string data) {
      if (data == "#") return nullptr;
      stringstream s(data);
      return makeDeserialize(s);
  }

  TreeNode *makeDeserialize(stringstream &s) {
      string str;
      getline(s, str, ','); // read a string splited by ,
      if (str == "#") return nullptr;

      // 前序遍历，解码要和编码对应上
      TreeNode *root = new TreeNode(stoi(str));
      auto l = makeDeserialize(s);
      auto r = makeDeserialize(s);
      root->left = l;
      root->right = r;
      // 由于局部变量l和r不会被任何东西改变，可以直接4句合并为2句。
      return root;
  }
};

98. Validate Binary Search Tree

class Solution2 {
 public:
  bool isValidBST(TreeNode *root) {
      return recurse(root, LONG_MIN, LONG_MAX);
  }

  bool recurse(TreeNode *root, long lower, long upper) {
      if (!root) return true;
    
      long val = root->val;
      if ((val <= lower) || (val >= upper)) {
          return false;
      }
      return recurse(root->left, lower, val) and recurse(root->right, val, upper);
  }
};

学习笔记

第三周：2020/08/24-2020/08/31。

本周感受：有点难，有点吃力，但还能跟得上。

第三周学习泛型递归，树的递归、回溯和分治。

关于泛型递归：超哥的比喻—盗梦空间，让人耳目一新。主角团队（即参数列表）在不同的梦境之间穿梭，在每一层对参数进行修改，并将修改携带回相邻的层。即所谓归去来兮的感觉。这种描述让我更加深刻的理解了递归的本质。并且开始尝试去理解这种思维逻辑，避免人肉递归。

关于树的递归：二叉树本身天然就是递归定义，因此题解基本都是基于递归（少量是是基于队列的层序遍历）。有一些题目还是不太好想，比如树的序列化与反序列化，二叉树的恢复等题目。之后还需要通过五毒神掌进行不断过遍数。

关于回溯：回溯就是递归，或者说回溯需要借助递归。它和递归的区别在于，回溯增加了撤回的操作（可以通过传拷贝消去此步骤，但是不建议，原因两点：一是破坏了回溯的直观完美对称性，不易理解，可读性也不强；二是传拷贝要比传引用的效率低下），从而体现选择与不选择的本质。典型题目有求生成括号、求子集、排列、组合、八皇后问题。

关于分治：分治就是递归，或者说分治需要借助递归。它和递归的区别在于，分治增加了切分子问题和合并子问题结果这两步操作。经典题目有：快排，合并K个数组/链表，快速幂。

相比于前两周，本周明显感觉吃力很多，递归的状态想不清楚，还是没有彻底的摆脱人肉递归。还需通过五毒神掌过遍数。记忆+理解+默写。最终达到直接能够在网页上，不借助任何IDE，一气呵成AC的效果。

学习心得：

  1. 关于递归回溯和分支，之前刷题都是零零散散的，没有认真思考过特性并抽取共同点，因此不同题目之间是孤立的，不仅容易遗忘，而且没有形成结构化的知识体系。通过超哥的讲解和题目分类练习，明显感觉自己对这部分的理解深刻和立体了很多。

  2. 我想说刷题真的不轻松，太虐心了。学习曲线很陡峭，需要花费大把的时间和精力，并且与业务相距较远。学习算法也许不如直接学习业务框架或者底层源码效果显著，但是它是优秀程序员必须具备技能，所以值得投入，也必须学好，加油。

simidagogogo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DSA算法实现数字签名--java实现
霓虹深处
06-05 1521
简介 DSA是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSfS(DigitalSignature Standard)。 DSA是基于整数有限域离散对数难题的，其安全性与RSA相比差不多。DSA的一个重要特点是两个素数公开，这样，当使用别人的p和q时，即使不知道私钥，你也能确认它们是否是随机产生的，还是作了手脚。RSA却做不到。 算法分类信息： 算法 密钥长度...
DSA-数据签名算法（理论）
热门推荐
aaqian1的博客
04-14 2万+
一、历史   1991年8月，NIST（Nation Institute of Standards and Technology，美国国家标准技术研究所）提出了数字签名算法（DSA）用于他们的数字签名标准（DSS）中。 DSA是算法，DSS是标准。标准采用算法，算法是标准的一部分。   但是NIST的通告引起了大量谴责，这些谴责的政治性多于学术性。许多已经取得RSA算法专利许可权的大型软件公司...
能用就行——玄学问题：Compile with TORCH_USE_CUDA_DSA to enable device-side assertions
饮tom的博客
09-18 2万+
尝试了网上的各种方法都无法解决，比如降低batchsize(之前设置128也成功跑完，现在设为16也无法跑完)、各种意义上的重装重启、设。点开任务管理器，发现每次都是提示这个问题都是因为爆显存了orz（但之前不会啊…搁置了一个月之后，再次使用就显示报错。，暂时没出现问题，能用就行🤪🤪。
OpenSSL命令---dsa
VitalityShow(网络通讯)
11-04 3982
dsa命令用于处理DSA密钥、格式转换和打印信息。该命令兼容了传统的SSLeay来用私钥进行加密：新的应用程序必须使用安全的PKCS#8格式。
Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
NKhth的博客
04-24 2万+
遇到这个报错，先别急着干其他的，先把device改成CPU试一试，可能就把真正的问题报出来了。
DSA数据安全隔离-源代码防泄密
LOL2018的博客
04-07 1996
换句话说，只保护 Office类文档数据，可选择DSM文档加密软件;只保护源代码等数据，可选择DSA数据安全隔离;至于数据特点、应用场景复杂的，则可以选择DLP数据泄露防护。
DSA数字签名-针对随机数k的共享k攻击&线性k攻击
ATFWUS的博客
10-17 1731
DSA数字签名算法是NIST在数字签名标准DSS中采用的签名算法，它公布于1994年5月19日的联邦记录上，并于1994年12月1日采纳为标准DSS。本文简单总结DSA算法针对随机数k的一些攻击方法。
dsa框架分析-以rtl8367为例
weixin_52627168的博客
12-04 1588
最近做了rtl8367的驱动移植，在做的过程中使用了dsa框架，在这向大家分享一下dsa的操作流程和如何使用dsa初始化switch。
conda环境下Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions问题解决
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
11-11 7151
Bert-VITS2语音训练语料中，不能包含英文字母，如果包含英文字母，则可能出现以上问题，通过正则表达式过滤掉包含英文字母的语料，问题解决。经过尝试发现，只保留一个人的100句语料进行语音训练，没有发生问题。尝试更换多个版本的torch和cuda，问题依旧存在。查看cuda和torch的版本。
RISC-V与DSA计算机架构
吴建明wujianming_110117
02-23 3266
RISC-V与DSA计算机架构 相信所有和计算机体系结构打过交道的朋友们都看过David Patterson与John Hennessy的煌煌巨作,《计算机体系架构：量化研究方法》。两位在计算机架构领域鼎鼎大名的教授，一个来自加州大学伯克利分校，另一个来自斯坦福。 首先上场的是David Patterson，为我们带来了关于指令集架构（ISA）的回顾以及RISC-V项目的展望。 （Patterson教授在演讲中） Patterson教授的演讲主题是50年来计算机体系架构（ISA为主）的回顾以及RISC-
DSA3-Heldenverwaltung-开源
04-27
《DSA3-Heldenverwaltung-开源》是一个专为角色扮演游戏系统DSA3（Das Schwarze Auge第三版）设计的英雄及英雄团队管理工具。这个工具的核心特点是其开源性质，这意味着源代码对公众开放，玩家和开发者可以自由查看...
dsa「DSA」-crx插件
03-10
为Chrome和Chrome OS提供分布式服务架构链接。 适用于Chrome和Chrome操作系统的分布式服务架构链接 支持语言:English (United States)
DSA-Module-3:DSA模组3
03-19
《DSA模组3：深入理解C++编程》 在数据结构与算法（DSA）的学习过程中，模组3通常会深入探讨C++编程语言的应用。C++作为一款强大的、面向对象的编程语言，是实现高效算法和复杂数据结构的理想选择。在这个模块中，...
DSA2001_E-1142351.pdf
09-07
这篇文档是关于"DSA2001"的一款硅基PNP型晶体管的详细规格说明，主要应用于一般放大电路，并且与DSC2001形成互补。该器件的主要特性包括： 1. 高正向电流转移比(hFE)：具有优秀的线性特性，这使得DSA2001在放大信号...
DSA - Half-Life-开源
04-26
《DSA - Half-Life》是一款基于开源游戏引擎的3D第一人称射击（FPS）游戏，由DSA-HL团队为著名角色扮演游戏"Das Schwarze Auge"（德语，直译为"黑暗之眼"，英文名为"The Dark Eye"）打造的新体验。这款作品的核心...
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 826
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 342
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
【算法】深入浅出聚类算法：原理、应用与Java实现
最新发布
一个不断前行的程序者
08-26 446
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
最小区间00
青釉Oo的博客
08-21 470
最小区间
let dsa=[2023-08-01:1,2023-08-02:3]如何用jquery将2023-08-02删除
07-15
根据你提供的代码，我看到你想要操作一个 JavaScript 数组 `dsa`，而不是 HTML 元素。在这种情况下，你可以使用 ... {"2023-08-02": 3}, {"2023-08-03": 5} ]; ``` 希望这可以帮到你！如有任何疑问，请随时追问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值