<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[J_learner的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/J_learner</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; J_learner]]></copyright><item><title><![CDATA[JavaScript|LeetCode|数学|204. 计数质数]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/106328605</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/106328605</guid><author>J_learner</author><pubDate>Mon, 25 May 2020 11:17:59 +0800</pubDate><description><![CDATA[看了题解
想法：

访问到一个质数时，结果加 1，同时将能被该质数整除的数排除（不是质数）

/** 
* @param {number} n 
* @return {number} 
*/
var countPrimes = function(n) {    
    // 题解：埃拉托斯特尼筛法在每次找到一个素数时，将能被素数整除的数排除掉。    
    var notPrime = [], i = 0, j = 0, ans = 0;    
    for(i = 0; i &lt; n; i+]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划/递归|650. 只有两个键的键盘]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/106189634</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/106189634</guid><author>J_learner</author><pubDate>Mon, 18 May 2020 12:20:30 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

copy all 算 1 次操作；paste 算 1 次操作
数组 dp：dp[i] 表示打印出 i 个 ‘A’ 的最少操作次数。


从前向后更新 dp ：找 i % j == 0 中，j 的最大值（n &gt;= i &gt; j &gt;= 1）
dp[i] = dp[j] + 1 + (i / j - 1)
dp[j]表示得到 j 个 A 所需的最少操作次数；1 表示 copy 这 j 个 A，(i / j - 1) 表示 paste 的次数（本身已经存在一份 j 个 A，]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|72. 编辑距离]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/106138561</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/106138561</guid><author>J_learner</author><pubDate>Fri, 15 May 2020 12:05:21 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

先看看题目给的例子：word1 = “horse”, word2 = “ros”


初始化：每增加一行，表示指向 word1 的指针（i）向后移动一个字符；每增加一列，表示指向 word2 的指针（j）向后移动一个字符；当一个字符串为空时，另一个串只需要不断删除字符即可；假设填写数字的部分为 dp 数组，里面的数字为使得 word1 和 word2 当前字符串（即从第 0 位到各自指针指向的位置）相等的最小操作数

进行表格的填写，发现规律
对于dp[1][1]，因为word1[]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|583. 两个字符串的删除操作]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/106115473</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/106115473</guid><author>J_learner</author><pubDate>Thu, 14 May 2020 12:17:10 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

参见 JavaScript|LeetCode|动态规划|1143. 最长公共子序列


假设 word1 和 word2 的最长公共子序列长度为 L


最小步数 = word1.length - L + word2.length - L

/** 
* @param {string} word1 
* @param {string} word2 
* @return {number} 
*/
var minDistance = function(word1, word2) {  ]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|188. 买卖股票的最佳时机 IV]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/106100631</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/106100631</guid><author>J_learner</author><pubDate>Thu, 14 May 2020 10:53:24 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

参见 JavaScript|LeetCode|动态规划|123. 买卖股票的最佳时机 III 的优化部分
该题中，规定了最多交易次数 k


用数组 buy 和 sell 来表示第 1 ~ k 次 买入 和 卖出 的最大收益


prices的长度对于交易次数有限制，故更新k的值： k = Math.min(k, prices.length / 2 向上取整)


修改（尽可能缩小） k 的值，有利于节省内存、缩短运行时间

/** 
* @param {number} k 
* ]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|123. 买卖股票的最佳时机 III]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/106053199</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/106053199</guid><author>J_learner</author><pubDate>Wed, 13 May 2020 10:52:04 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

A[i]：第 i 天买入的最大利润；B[i]：第 i 天卖出的最大利润


A[i][0] 表示在第 i 天 第 0 次买入
B[i][0] 表示在第 i 天 第 0 次卖出
依次类推


第 0 次卖出 -&gt; 第 1 次买入 -&gt; 第 1 次卖出 -&gt; 第 2 次买入 -&gt; 第 2 次卖出
最大利润在：第 0 次卖出 / 第 1 次卖出 / 第 2 次卖出 时取得

/** 
* @param {number[]} prices 
* @return {n]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|714. 买卖股票的最佳时机含手续费]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105988471</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105988471</guid><author>J_learner</author><pubDate>Fri, 08 May 2020 10:39:49 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

数组dp保存每一天的利润最大值
在第 i 天，对于第 j (j &lt; i)天的股票：dp[i]=Math.max(dp[i],dp[j]+prices[i]−prices[j]−fee,dp[j])dp[i] = Math.max(dp[i], dp[j] + prices[i] - prices[j] - fee, dp[j])dp[i]=Math.max(dp[i...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|309. 最佳买卖股票时机含冷冻期]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105949641</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105949641</guid><author>J_learner</author><pubDate>Thu, 07 May 2020 11:36:15 +0800</pubDate><description><![CDATA[法1：动态规划
想法1：

第 i 天时，将 prices[i] 与 prices[j] (j &lt; i) 比较，意思是：在第 j 天买入，第 i 天卖出（也可能是第 j 天正持有一只股票，而不是购入新股）。会有以下两种情况出现


prices[j] &gt; prices[j - 1]：那么在第 j 天持有股票，或可以买入股票。
dp[i]=Math.max(dp[i],dp[j]+pri...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|377. 组合总和 Ⅳ]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105914549</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105914549</guid><author>J_learner</author><pubDate>Mon, 04 May 2020 11:22:51 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

target 为背包
nums 中的正整数为物品，正整数的值为物品体积，物品可以无限次放入
dp数组保存目标数为 0 到 target 时的组合个数（初始化dp[0]为1，方便后续组合个数的计算。比如：如果 target 存在于 nums 中，则正好装得下，dp[target]++；因为都采取的dp[target] + 剩余容量组合数（此时剩余容量为0），所以dp[tar...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划/BFS|139. 单词拆分]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105856595</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105856595</guid><author>J_learner</author><pubDate>Fri, 01 May 2020 11:33:30 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

字符串 s 是背包
单词列表 wordDict 中的单词是物品
物品可重复放入背包
数组dp：


dp[i]表示：s 中以 s[0] 开头的 i 长度的子串 代表的 背包，是否可正好被单词装满

/** 
* @param {string} s 
* @param {string[]} wordDict 
* @return {boolean} 
*/
var word...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|518. 零钱兑换 II]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105836463</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105836463</guid><author>J_learner</author><pubDate>Wed, 29 Apr 2020 11:50:43 +0800</pubDate><description><![CDATA[法1：动态规划
看了题解
想法：

数组dp，保存背包容量为0到amount时，用硬币装满背包的方式数
动态规划关注于当下；思考：对于当前面额硬币装或者不装?（是否能装下？是否应该装？）
对于数组dp从前往后更新，可实现同一面额硬币多次装入

/** 
* @param {number} amount 
* @param {number[]} coins 
* @return {number} 
...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|322. 零钱兑换]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105700252</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105700252</guid><author>J_learner</author><pubDate>Wed, 29 Apr 2020 11:30:09 +0800</pubDate><description><![CDATA[法1：动态规划
看了题解
想法：

总金额amount是背包容量
coins是物品（coins.length是物品种类；coins[i]为每种物品的体积）
每种物品有无限个
目标：用最少数量的物品把背包填满

/** 
* @param {number[]} coins 
* @param {number} amount 
* @return {number} 
*/
var coinChange...]]></description><category></category></item><item><title><![CDATA[[flask框架]下：前端发起请求，服务器用[python]读取[本地图片]并转码[base64]，传至前端显示]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105681873</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105681873</guid><author>J_learner</author><pubDate>Wed, 22 Apr 2020 15:24:56 +0800</pubDate><description><![CDATA[前端 jQuery + AJAX 请求

$.ajax({
    type : 'POST', // POST方法
    
    // 服务器所在，注意要与app.py中的
    // @app.route('/back_end', methods=['POST', 'GET'])
    // 中的第一个参数相对应
    url : '/back_end', 

    // 将da...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|474. 一和零]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105676726</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105676726</guid><author>J_learner</author><pubDate>Wed, 22 Apr 2020 11:04:42 +0800</pubDate><description><![CDATA[法1：动态规划
看了题解
想法：

0 和 1 是两个背包，m 是 0 背包的容量，n 是 1 背包的容量
字符串是物品
需要当前物品的 0 和 1 都可以被装下，才可以放得进背包（仍然存在选择：如果放入之后，总的字符串数量最大，则放入；否则不放入）
背包的容量越大，越可能放入更多的物品，所以最后返回dp[m][n]

/** 
* @param {string[]} strs 
* @param...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划/递归|494. 目标和]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105576378</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105576378</guid><author>J_learner</author><pubDate>Mon, 20 Apr 2020 11:21:46 +0800</pubDate><description><![CDATA[法1：动态规划
看了题解
想法：

思考：什么是背包？什么是物品？


将nums分为P（加+）和N（加-）两部分
sums( P ) + sums( N ) = sums(nums)
sums( P ) - sums( N ) = S
=&gt; sums( P )  = (sums(nums) + S) / 2
则只需要选取数组中元素加入背包（这些数前面加+），使得背包正好被装满；求装满的方法...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|416. 分割等和子集]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105551373</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105551373</guid><author>J_learner</author><pubDate>Thu, 16 Apr 2020 10:17:58 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

将两个子集看作背包（容量均为数组元素和 / 2），数组中的数字作为物品（每个数字的值作为每个物品的体积）
问题：如何使得两个背包背的物品体积相等呢？ 回答：只需要使得一个背包可以正好装满即可！
数组dp表示：容量为0~(数组元素和 / 2)的背包，可以容纳的物品的最大体积和

/** 
* @param {number[]} nums 
* @return {boolea...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|1143. 最长公共子序列]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105488080</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105488080</guid><author>J_learner</author><pubDate>Mon, 13 Apr 2020 14:33:05 +0800</pubDate><description><![CDATA[法1：动态规划
看了题解
推荐去看 力扣 的该题题解
想法：

创建数组dp：dp[i][j]保存text1前i个、text2前j个字符中的两者的最长公共子序列；dp[0][j]和dp[i][0]均为0，因为此时表示text1或text2取空字符串时

/** 
* @param {string} text1
* @param {string} text2 
* @return {number} ...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划/贪心思想|376. 摆动序列]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105409584</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105409584</guid><author>J_learner</author><pubDate>Fri, 10 Apr 2020 12:29:22 +0800</pubDate><description><![CDATA[法1：动态规划
想法1：

数组dp保存以nums[i]结尾的摆动序列的最长子序列长度
数组larger保存以nums[i]结尾的摆动序列的最长子序列中：nums[i]比前一个数小/大：false表示小，true表示大（用于判断当前数能否衔接到nums[i]之后）

/** 
* @param {number[]} nums 
* @return {number} 
*/
var wiggleMa...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划/贪心算法|646. 最长数对链]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105384294</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105384294</guid><author>J_learner</author><pubDate>Wed, 08 Apr 2020 15:56:35 +0800</pubDate><description><![CDATA[法1：动态规划
看了题解
想法：

对所有数对pairs：按照每个数对的第一个数进行升序排列
数组dp保存以pairs[i]结尾的最长数对链的长度
dp[i]的值：


若pairs[i][0] &gt; pairs[j][1] (i &gt; j)，则dp[i] = dp[j] + 1;
否则，dp[i] = dp[i];
注：dp[j] &gt;= dp[k] (j &gt; k)

/** ...]]></description><category></category></item><item><title><![CDATA[JavaScript|LeetCode|动态规划|300.最长上升子序列]]></title><link>https://blog.youkuaiyun.com/J_learner/article/details/105288764</link><guid>https://blog.youkuaiyun.com/J_learner/article/details/105288764</guid><author>J_learner</author><pubDate>Fri, 03 Apr 2020 11:27:52 +0800</pubDate><description><![CDATA[法1：动态规划
想法：

用数组dp保存：以nums[i]结尾的最长上升子序列长度
对于nums中每个数，dp[i]初始化为1，至少包含nums[i]本身
对于nums[i]，要求dp[i]，关键在于：找到dp[j]，nums[j] &lt; nums[i] (j &lt; i)，则dp[i] = dp[j] + dp[i]。注：需找到符合条件的dp[j]的最大值
最长上升子序列可能以 nums[...]]></description><category></category></item></channel></rss>