<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[rpybd的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/rpybd</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; rpybd]]></copyright><item><title><![CDATA[LeetCode#811 Subdomain Visit Count]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/98480181</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/98480181</guid><author>rpybd</author><pubDate>Mon, 05 Aug 2019 10:44:41 +0800</pubDate><description><![CDATA[1、关键就在于分词。
2、（1）string的find()函数查找的是字符（串）出现位置的下标，而非迭代器！
（2）、int转string：全局函数std::to_string
string转int：std::stoi/stol/stoll https://zh.cppreference.com/w/cpp/string/basic_string/stol
class Solution {
pub...]]></description><category></category></item><item><title><![CDATA[LeetCode#211  Add and Search Word - Data structure design]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/98480101</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/98480101</guid><author>rpybd</author><pubDate>Mon, 05 Aug 2019 10:40:12 +0800</pubDate><description><![CDATA[1、本题与先前的Trie树相比，最大的差别就在引入了对通配符".“的处理。但由于引入此，就需要在出现”."的同一节点分支全部进行搜索，才能不漏掉所有可能。
2、搜索采用递归较好。
class WordDictionary {
private:
    struct TNode{
        char key;
        map&lt;char, TNode*&gt; node;
    ...]]></description><category></category></item><item><title><![CDATA[LeetCode#199 Binary Tree Right Side View]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/97798609</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/97798609</guid><author>rpybd</author><pubDate>Tue, 30 Jul 2019 17:04:30 +0800</pubDate><description><![CDATA[以层为单位，取每层最右（结束）处的元素。
#define SIZE 32
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left...]]></description><category></category></item><item><title><![CDATA[LeetCode#208 Implement Trie-Prefix Tree]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/97791374</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/97791374</guid><author>rpybd</author><pubDate>Tue, 30 Jul 2019 16:03:21 +0800</pubDate><description><![CDATA[LeetCode#208 Implement Trie-Prefix Tree
1、C++使得struct也能作为类使用，可以包含函数。同时struct可以有自己的构造函数
其定义方法为（1)
struct TNode{
    char key;
    map&lt;char, TNode*&gt; NextMap;
};

实际上，可以在定义的同时创建一个对象，如（2）
struct TNo...]]></description><category></category></item><item><title><![CDATA[LeetCode#23 Unique Binary Search Trees]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82808471</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82808471</guid><author>rpybd</author><pubDate>Fri, 21 Sep 2018 23:32:19 +0800</pubDate><description><![CDATA[1、对于任意一个数，它为根时不同的二叉搜索树个数是左子树个数与右子树个数的乘积，左右子树又各自分治下去。因此，n个数有多少种其实就是1~n每一个作为根节点不同的二叉搜索树个数的和。更长的序列会用到先前序列的结果，是典型的动态规划思想。
需要注意的是边界条件：左边没有或只有一个节点时都记为1
2、直接用公式也是可以的
class Solution {
public:
    int numTrees...]]></description><category></category></item><item><title><![CDATA[LeetCode#877 Stone Game]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82808125</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82808125</guid><author>rpybd</author><pubDate>Fri, 21 Sep 2018 22:28:03 +0800</pubDate><description><![CDATA[1、直接判胜；
2、计算从i到j的胜利点数。这里用超过对手的点数来表示胜负。
首先，既然d[0][n-1] = max(p[0]-d[1][n-1], p[n]-d[0][n-2] ，那么，这样依次扫描即可。但需要注意的是边界条件，即d[i][j] 是什么：需要计算每一个区间的最值。这里使用区间距离来拆分，即将其拆成多个长度为1/2/3…/n的区间分别计算每个区间最值，才能得出d[0][n-1]
...]]></description><category></category></item><item><title><![CDATA[LeetCode#413 Arithmetic Slices]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82808067</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82808067</guid><author>rpybd</author><pubDate>Fri, 21 Sep 2018 22:21:23 +0800</pubDate><description><![CDATA[1、对于三个数的等差数组，计数+1；对于多个数的等差数组，拆分，公式为(c-2)*(c-1)/2 。用一个sum累加即可，count随用虽丢。注意边界条件及状态转移。
class Solution {
public:
    int numberOfArithmeticSlices(vector&amp;lt;int&amp;gt;&amp;amp; A) {
        int n = A.size();
    ...]]></description><category></category></item><item><title><![CDATA[LeetCode#64 Minimum Path Sum]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82808030</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82808030</guid><author>rpybd</author><pubDate>Fri, 21 Sep 2018 22:17:16 +0800</pubDate><description><![CDATA[1、对于一个矩阵，可以按照向右或向下将其拆分。右下角的值取上或左中较小值即可。依次遍历即可。
class Solution {
public:
    int minPathSum(vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;&amp;amp; grid) {
        int m = grid.size();
        int n = grid[0].size();
   ...]]></description><category></category></item><item><title><![CDATA[LeetCode# 338 Counting Bits]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82808005</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82808005</guid><author>rpybd</author><pubDate>Fri, 21 Sep 2018 22:13:19 +0800</pubDate><description><![CDATA[1、mark一下
class Solution {
public:
    vector&amp;lt;int&amp;gt; countBits(int num) {
        vector&amp;lt;int&amp;gt; result(num+1, 0);
        result[0] = 0;
        for(int i = 1; i &amp;lt;= num; i++){
            re...]]></description><category></category></item><item><title><![CDATA[LeetCode#121 Best Time to Buy and Sell Stock]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82807918</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82807918</guid><author>rpybd</author><pubDate>Fri, 21 Sep 2018 22:01:43 +0800</pubDate><description><![CDATA[1、从左至右遍历，当前区间的最大利润是前一个区间的最大利润或当前股票价值减前一个区间最小值，取高者。每一个区间都有一个利润与最小值，依次比较替换即可。
class Solution {
public:
    int maxProfit(vector&amp;lt;int&amp;gt;&amp;amp; prices) {
        if(prices.size() == 0 || prices.size() =...]]></description><category></category></item><item><title><![CDATA[LeetCode#303 Range Sum Query]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82807886</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82807886</guid><author>rpybd</author><pubDate>Fri, 21 Sep 2018 21:57:21 +0800</pubDate><description><![CDATA[1、利用动态规划思想，sum(i, j) 实际上是sum(0, j) - sum(0, i-1) 。
2、构造一个逐次累加和的数组，返回i、j两项相减结果即可。
class NumArray {
public:
    NumArray(vector&amp;lt;int&amp;gt; nums) {
        sums.clear();
        sums.push_back(0);
      ...]]></description><category></category></item><item><title><![CDATA[LeetCode#53 Maximum Subarray]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82535093</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82535093</guid><author>rpybd</author><pubDate>Sun, 09 Sep 2018 01:16:00 +0800</pubDate><description><![CDATA[1、对于当前已计算区间，只要sum&amp;lt;0则丢弃。单独的result记录历史最高，选取当前高于其的sum替换。



class Solution {
public:
    int maxSubArray(vector&amp;lt;int&amp;gt;&amp;amp; nums) {
        int sum = 0;
        int result = nums[0];
        for(i...]]></description><category></category></item><item><title><![CDATA[LeetCode#746 Min Cost Climbing Stairs]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82535079</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82535079</guid><author>rpybd</author><pubDate>Sun, 09 Sep 2018 01:10:50 +0800</pubDate><description><![CDATA[1、同#53、#121，都是不断取最好结果。 
这里是：最后必定需要判断从i-1或i-2抵达的花费，因此层层递推，最后算到2和3的为为止。



class Solution {
public:
    int minCostClimbingStairs(vector&amp;lt;int&amp;gt;&amp;amp; cost) {
        cost.push_back(0);
        int n ...]]></description><category></category></item><item><title><![CDATA[LeetCode#628 Maximum Product of Three Numbers]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82535047</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82535047</guid><author>rpybd</author><pubDate>Sun, 09 Sep 2018 00:58:45 +0800</pubDate><description><![CDATA[1、一种办法是遍历，取出最大两个数、最小两个数，然后分情况讨论。 
2、排序后直接讨论也可以： 
     （1）、全为非负数或全为负，确定； 
     （2）、仅有一个负数，确定（同全为非负）； 
     （3）、存在两个以上负数与一个正数：比较即可。

class Solution {
public:
    int maximumProduct(vector&amp;lt;int&amp;gt;&amp;amp...]]></description><category></category></item><item><title><![CDATA[LeetCode#830 Positions of Large Group]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82535036</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82535036</guid><author>rpybd</author><pubDate>Sun, 09 Sep 2018 00:53:33 +0800</pubDate><description><![CDATA[1、仍然考虑建索引map，存储起始位置。当然，仅3个以上才存，这在遍历时可以做到。最后只需要遍历map即可。



class Solution {
public:
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; largeGroupPositions(string S) {
        int n = S.size();
        if(n &amp;lt; 3)
  ...]]></description><category></category></item><item><title><![CDATA[LeetCode#88 Merge Sorted Array]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82535029</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82535029</guid><author>rpybd</author><pubDate>Sun, 09 Sep 2018 00:50:28 +0800</pubDate><description><![CDATA[1、启用额外空间中转当然可以； 
2、使用尾指针从后往前填充。注意两点：n先被用完之后即停止、使用三元式时一定要注意赋值的先后：m是否被完全填充与tail[p1]

class Solution {
public:
    void merge(vector&amp;lt;int&amp;gt;&amp;amp; nums1, int m, vector&amp;lt;int&amp;gt;&amp;amp; nums2, int n) {
 ...]]></description><category></category></item><item><title><![CDATA[LeetCode#35 Search Insert Position]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82534932</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82534932</guid><author>rpybd</author><pubDate>Sun, 09 Sep 2018 00:25:38 +0800</pubDate><description><![CDATA[1、二分是较好的方法：但这里要注意区间取值的细节。 
     首先，我们可以得出这样的结论：插入元素满足nums[i-1]&amp;lt;target&amp;lt;=nums[i] 也就是说或者较大，在其之后；或者替换（较小或相等）。知道了这一点就好确定区间的取法与判断的边界条件了：首先，不能左右边界相等，因为最后区间一定会收敛在一个数上，但可能不存在；



        int leftPtr = 0;...]]></description><category></category></item><item><title><![CDATA[LeetCode#697 Degree of Array]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82533236</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82533236</guid><author>rpybd</author><pubDate>Sat, 08 Sep 2018 20:57:13 +0800</pubDate><description><![CDATA[1、比较笨的方式是先用vector给每一个元素计数（注意这个vector的长度，原数组可能有负数），然后找到degree并记录哪些元素是候选项；再针对每一个候选项遍历原数组。 
     很笨的方法但很有效；

if(nums.size() == 1)
    return 1;
vector&amp;lt;int&amp;gt;::iterator iter = max_element(nums.begin()...]]></description><category></category></item><item><title><![CDATA[LeetCode#217 Contains Duplicate]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82432858</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82432858</guid><author>rpybd</author><pubDate>Wed, 05 Sep 2018 23:52:30 +0800</pubDate><description><![CDATA[1、首先，范围在整数内，且有可能不连续，因此考虑提取最大元素与最小元素，构造一个能够为原数组中正负所有元素索引的空间，max+(min &amp;lt; 0 ? abs(min) : 0) + 1 作为大小，对每一个nums[i] 对应的位置标记（注意min为负数导致的偏移）。 
2、利用hash表也是一种思路 
3、vector有min_element()函数，用迭代器确定位置，可以写成begin(ar...]]></description><category></category></item><item><title><![CDATA[LeetCode#448 Find All Numbers Disappeared in Array]]></title><link>https://blog.youkuaiyun.com/rpybd/article/details/82432386</link><guid>https://blog.youkuaiyun.com/rpybd/article/details/82432386</guid><author>rpybd</author><pubDate>Wed, 05 Sep 2018 23:05:15 +0800</pubDate><description><![CDATA[1、最慢的方式是两层for循环，不考虑； 
2、更先进的方法是这样的：不考虑是否直接出现了这个数，而考虑这个数是否出现在了下标中，即：以nums[i] 为索引标记这个位置，最后没有标记的位置就是缺失的数。也就是将数组中的数看作索引。这里被标记处的数置负，abs后可以重新使用。 
3、为了优化性能，可以使用双目运算符； 
4、在牺牲空间的前提下，可以省去第一次标记时的判断



class Solu...]]></description><category></category></item></channel></rss>