<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Alicepus的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/Alicepus</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; Alicepus]]></copyright><item><title><![CDATA[区间dp _P1220关路灯]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/108690239</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/108690239</guid><author>Alicepus</author><pubDate>Sun, 20 Sep 2020 10:40:10 +0800</pubDate><description><![CDATA[这是一道区间型的动态规划题；

我主要是对前方的一些dp题解补充一些小细节。

既然是动规，那么首先讲一下常用的填表法和刷表法：

填表法就是利用状态转移方程和上一个状态来推导出现在的状态（相当于知道已知条件，将答案填入）

刷表法就是利用当前的状态，把有关联的下一状态都推出来。

这道题我选用的是填表法。

理解一下题目大意：

关灯不需要额外的时间，经过了灯就关了。但是可能折返回去关某一个大灯会比继续往下走关接下来的一个小灯更优，

那么可以得到两种状态（沿着当前方向继续往下走，改变方向回去关灯）。

]]></description><category></category></item><item><title><![CDATA[单调列队]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/108431484</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/108431484</guid><author>Alicepus</author><pubDate>Sun, 06 Sep 2020 14:49:13 +0800</pubDate><description><![CDATA[// 单调列队
vector&lt;int&gt; res;

class MonotonicQueue {
private:
    deque&lt;int&gt; data;
public:
    void push(int n) {
        while (!data.empty() &amp;&amp; data.back() &lt; n) {
            data.pop_back();
        }
        data.push_back(n);   
   ]]></description><category></category></item><item><title><![CDATA[Leetcode 257.二叉树的所有路径]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/108397990</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/108397990</guid><author>Alicepus</author><pubDate>Fri, 04 Sep 2020 09:41:59 +0800</pubDate><description><![CDATA[class Solution {
public:
    vector&lt;string&gt; binaryTreePaths(TreeNode* root) {
        vector&lt;string&gt; paths;  // result
        if (root == nullptr) {
            return paths;
        }
        queue&lt;TreeNode*&gt; node_queue; 
        queue&]]></description><category></category></item><item><title><![CDATA[位运算]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107524146</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107524146</guid><author>Alicepus</author><pubDate>Wed, 22 Jul 2020 21:54:53 +0800</pubDate><description><![CDATA[文章目录1.lowbit  计算一个数二进制下最低位 1 对应的值判断一个数x二进制下的第i位是否为1将一份数字x二进制下第位改为1计算一个数字x二进制下含有1或0的个数判断一个数x是否为 2 的n次方对 1 ^ （异或）
1.lowbit  计算一个数二进制下最低位 1 对应的值
int lowbit(int x) {
	return x&amp;(-x)
}

判断一个数x二进制下的第i位是否为1
bool isOne(int x) {
	int i; 
	// 想办法取出x的第 i 位 
	retur]]></description><category></category></item><item><title><![CDATA[递归_95.不同的二叉搜索树 II(20200721)]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107479889</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107479889</guid><author>Alicepus</author><pubDate>Tue, 21 Jul 2020 08:13:27 +0800</pubDate><description><![CDATA[// 1.思路对于一颗二叉搜索树以及每一颗子树，由基本性质
// 2.索引 1 ~ i-1 显然对应左子树， i+1 ~ n对应右子树 i 为根
// 3.先枚举每一个可行的根节点
// 4.按照 2 递归的找出每一颗子树的左子树和右子树
// 5.把递归出的左子树和右子树接到对应的根上
// 6.把得到的答案返回
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *l]]></description><category></category></item><item><title><![CDATA[动态规划 & 搜索_312.戳气球（20200719）]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107439739</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107439739</guid><author>Alicepus</author><pubDate>Sun, 19 Jul 2020 08:14:28 +0800</pubDate><description><![CDATA[动态规划
// 1.定义 dp[i][j] 为区间 （i, j）内最大可获得硬币数
// 2.状态转移 —— 
// 		2.1 dp[i][j] = |k=i+1, j-1| max val[i]*val[k]*val[j] + dp[i][k] + dp[k][j] ,  i &lt; j-1
// 		2.2 0 , i &gt;= j - 1
// 3.base case :
// 		3.1 val[0] = val[n + 1] = 1;
// 4. ans = dp[0][n+1]
class]]></description><category></category></item><item><title><![CDATA[牛客_牛客编程巅峰赛S1第4场 - 青铜&白银]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107436172</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107436172</guid><author>Alicepus</author><pubDate>Sat, 18 Jul 2020 22:11:44 +0800</pubDate><description><![CDATA[A
毫无意义
B 浅尝辄止


 
class Solution {
public:
    const int mod=998244353;
    /**
     *
     * @param n long长整型
     * @return int整型
     */
    #define ll long long
    int work(long long n) {
        // write code here
        ll ans=0;
        for(ll l=1]]></description><category></category></item><item><title><![CDATA[动规_97.交错字符串(20200718)]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107423849</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107423849</guid><author>Alicepus</author><pubDate>Sat, 18 Jul 2020 09:13:15 +0800</pubDate><description><![CDATA[常规 &amp; 解析
/** 1. 显然是动规
	2. 状态转移：
		p = i + j - 1; 
		2.1 dp[i][j] |= (dp[i - 1][j] &amp;&amp; s1[i - 1] == s3[p]);
        2.2 dp[i][j] |= (dp[i][j - 1] &amp;&amp; s2[j - 1] == s3[p]);  
	3. 定义 ： 
		3.1  p 对应 s3 中串的位置
		3.2  dp[i][j] 动规其实就是暴力遍历了啦，你懂的
		3]]></description><category></category></item><item><title><![CDATA[动规_1143.最长公共子序列]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107408531</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107408531</guid><author>Alicepus</author><pubDate>Fri, 17 Jul 2020 15:01:22 +0800</pubDate><description><![CDATA[// 状态转移 ：
// 1.正常匹配 ：dp[i][j] = dp[i - 1][j - 1] + 1;
// 匹配就取左上角的值 + 1
// 2.未匹配 ：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
// 未匹配就取左 / 上 中最大的一个
class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int rows = tex]]></description><category></category></item><item><title><![CDATA[散列表]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107401811</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107401811</guid><author>Alicepus</author><pubDate>Fri, 17 Jul 2020 10:10:20 +0800</pubDate><description><![CDATA[解决散列冲突 :
1. 开放寻址法

线性探测

二次线性探测
在 1 的基础上，探测第二次
再哈希
使用不同的哈希算法来存放（可能用多个）

2. 链地址法

如图，一次hash后链式存储

]]></description><category></category></item><item><title><![CDATA[树遍历_538.把二叉搜索树转换为累加树（20200717）]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107399713</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107399713</guid><author>Alicepus</author><pubDate>Fri, 17 Jul 2020 08:04:10 +0800</pubDate><description><![CDATA[/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int preSum  = 0; // 共享单元
    public TreeNode convertBST(Tree]]></description><category></category></item><item><title><![CDATA[滑动窗口]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107396141</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107396141</guid><author>Alicepus</author><pubDate>Thu, 16 Jul 2020 22:53:48 +0800</pubDate><description><![CDATA[文章目录框架例题最小覆盖字串(Leetcode 76)找到字符串中所有字母异位词（Leetcode 438）无重复字符串最长子串（Leetcode 3）
框架
// 定义左右指针
int left = 0, right = 0;
// 维护一个 window 窗口
while (right &lt; s.size()) {
    window.add(s[right++]); // 右指针 向右移动
    
    while (valid) {
        window.remove(s[left]]></description><category></category></item><item><title><![CDATA[快速幂]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107394602</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107394602</guid><author>Alicepus</author><pubDate>Thu, 16 Jul 2020 21:39:27 +0800</pubDate><description><![CDATA[int powMod(int a, int b, int mod){
    int res = 1;
    while (b){
        if (b&amp;1) res = (res*a) % mod;
        a = (a*a) % mod;
        b &gt;&gt;= 1;
    }
    return res;
}



]]></description><category></category></item><item><title><![CDATA[分治_三分_峰值]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107391382</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107391382</guid><author>Alicepus</author><pubDate>Thu, 16 Jul 2020 19:31:50 +0800</pubDate><description><![CDATA[算法模板
/* 查找函数最大值*/
#define target 1e-6 // 精度
// 定义一个计算函数 Caculate
int BinarySearch(double low, double high) {
    double left, right;
    double mid, mid_mid;
    left = low; // 设置当前查找区间上界
    right = high; // 设置当前查找区间下界的初值
    while (right-left &gt; target]]></description><category></category></item><item><title><![CDATA[搜索&图论_785.判断二分图（20200716）]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107374601</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107374601</guid><author>Alicepus</author><pubDate>Thu, 16 Jul 2020 08:01:53 +0800</pubDate><description><![CDATA[文章目录分析算法流程：DFSBFS
分析


对于图中的任意两个节点 u 和 v，如果它们之间有一条边直接相连，那么 u 和 v 必须属于不同的集合。


如果给定的无向图连通，那么我们任选一个节点开始，染成红色。随后我们对整个图进行遍历，将该节点直接相连的所有节点染成绿色，表示这些节点不能与起始节点属于同一个集合。我们再将这些绿色节点直接相连的所有节点染成红色，以此类推，直到无向图中的每个节点均被染色。


如果我们能够成功染色，那么红色和绿色的节点各属于一个集合，这个无向图就是一个二分图；如果我们未能成]]></description><category></category></item><item><title><![CDATA[拓扑排序与关键路径]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107371402</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107371402</guid><author>Alicepus</author><pubDate>Wed, 15 Jul 2020 22:15:05 +0800</pubDate><description><![CDATA[文章目录理论AOV 网判定任意一条拓扑排序字典序最小的一条路径【例题】1.拓扑排序的判定2.输出拓扑排序结果3.拓扑排序的应用
理论
拓扑排序（只适用于AOV网（有向无环图））
运用 ： 事务先后（非唯一）
拓扑排序思路：
1.选择一个入度为 0 的点 并输出
2.从AOV网中删除此顶点以及此顶点为起点的所有关联边
3.重复上述两步，直到不存在入度为0的顶点为止
4.如果书粗糙顶点数小于AOV网中的顶点数，则输出“有回路信息”，否则输出的顶点序列就是一种拓扑排序
算法实现：
1.数据结构： indgr[i]]]></description><category></category></item><item><title><![CDATA[动态规划 & 数学_96.不同的二叉搜索树（20200715）]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107351461</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107351461</guid><author>Alicepus</author><pubDate>Wed, 15 Jul 2020 06:58:26 +0800</pubDate><description><![CDATA[动态规划
// 动态规划 时间 O(n^2), 空间 O(n)
// 1. 1 ... i-1 作为左子树
// 2. i+1 ... n 作为右子树
// 3. 递归构建，由于根值不同，每颗二叉搜索树唯一
// 4. dp[n] : 长度为 n 的序列能构成不同二叉搜索树的个数
// 5. F[i, n] : 以 i 为根、序列长度为 n 的不同二叉搜索树个数（1 &lt;= i &lt;= n）
// 6. 确定状态转移：dp[i] += dp[j-1] * dp[i-j];
// 7. base ca]]></description><category></category></item><item><title><![CDATA[图论_最小生成树算法]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107347785</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107347785</guid><author>Alicepus</author><pubDate>Tue, 14 Jul 2020 21:19:29 +0800</pubDate><description><![CDATA[文章目录1.Kruskal2.Prim
1.Kruskal
#include&lt;iostream&gt;
using namespace std;

struct Edge{
    int u,v,w;
    bool operator &lt;(Edge K)const{
        return w&lt;K.w;
    }
} edge[N];
int n,m;
int father[N],res;
int mst=0;

int Find(int x){
    if(father[x]]></description><category></category></item><item><title><![CDATA[深度优先搜索（DFS） & 广度优先搜索(BFS)总结]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107346252</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107346252</guid><author>Alicepus</author><pubDate>Tue, 14 Jul 2020 20:48:30 +0800</pubDate><description><![CDATA[文章目录深度优先1.算法模板2.例题2.1 n 皇后问题（洛谷）2.2 素数环（洛谷）2.3 全排列（洛谷）2.4 马的遍历（洛谷）广度优先1.算法模板2.例题2.1 Dungeon Master（洛谷）2.2走迷宫2.3 Knight Moves（洛谷）
深度优先
1.算法模板
void dfs(int i)	// 核心代码
{
    if ( 1.到达推出条件 ) {
       	// 搜索结束， 退出
    }
    for ( 2.遍历所有可能 ) {
        if ( 3.满足走]]></description><category></category></item><item><title><![CDATA[动态规划_120.三角形最小路径和（20200714）]]></title><link>https://blog.youkuaiyun.com/Alicepus/article/details/107329628</link><guid>https://blog.youkuaiyun.com/Alicepus/article/details/107329628</guid><author>Alicepus</author><pubDate>Tue, 14 Jul 2020 07:06:49 +0800</pubDate><description><![CDATA[// 动态规划 ？ 其实说成是模拟暴力都不为过
// 状态转移：f[j] = min(f[j-1], f[j]) + triangle[i][j];
// base case: 对每一行最右边的位置初始化
// f[i] = f[i-1] + triangle[i][i];
class Solution {
public:
    int minimumTotal(vector&lt;vector&lt;int&gt;&gt;&amp; triangle) {
        int n = triangl]]></description><category></category></item></channel></rss>