Alicepus的博客

class Solution {public: vector<string> binaryTreePaths(TreeNode* root) { vector<string> paths; // result if (root == nullptr) { return paths; } queue<TreeNode*> node_queue; queue&

// 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

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

/** * 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

文章目录分析算法流程：DFSBFS分析对于图中的任意两个节点 u 和 v，如果它们之间有一条边直接相连，那么 u 和 v 必须属于不同的集合。如果给定的无向图连通，那么我们任选一个节点开始，染成红色。随后我们对整个图进行遍历，将该节点直接相连的所有节点染成绿色，表示这些节点不能与起始节点属于同一个集合。我们再将这些绿色节点直接相连的所有节点染成红色，以此类推，直到无向图中的每个节点均被染色。如果我们能够成功染色，那么红色和绿色的节点各属于一个集合，这个无向图就是一个二分图；如果我们未能成

//class MonotonicQueue {private: deque<int> data;public: void push(int n) { while (!data.empty() && data.back() < n) { data.pop_back(); } data.push_back(n); } int max() { return data.

// 两遍 hash 表// time: O(max(m, n)) space:O(max(m, n))class Solution {public: vector<int> intersect(vector<int>& nums1, vector<int>& nums2) { unordered_map<int,int> hash; vector<int> res;

动态规划// 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 < j-1// 2.2 0 , i >= j - 1// 3.base case :// 3.1 val[0] = val[n + 1] = 1;// 4. ans = dp[0][n+1]class

常规 & 解析/** 1. 显然是动规 2. 状态转移： p = i + j - 1; 2.1 dp[i][j] |= (dp[i - 1][j] && s1[i - 1] == s3[p]); 2.2 dp[i][j] |= (dp[i][j - 1] && s2[j - 1] == s3[p]); 3. 定义 ： 3.1 p 对应 s3 中串的位置 3.2 dp[i][j] 动规其实就是暴力遍历了啦，你懂的 3

// 状态转移 ：// 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

动态规划// 动态规划 时间 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 <= i <= n）// 6. 确定状态转移：dp[i] += dp[j-1] * dp[i-j];// 7. base ca

// 动态规划 ？ 其实说成是模拟暴力都不为过// 状态转移：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<vector<int>>& triangle) { int n = triangl

198.打家劫舍// 1.不可以盗窃相邻// 2.状态转移 dp[i] = max(dp[i-1], num[i] + dp[i-2])// 3.状态压缩呀 ~ dp_1, dp_2// 似乎就解决了勒？// 4. base case 一开始都是 0 class Solution {public: int rob(vector<int> &nums) { if(nums.size() == 0) return 0; int dp_i

// java/**1. 显然是动规问题，但正向动规是错的2. 为什么？3. 我来举个例子4. 由于存在增加生命值的情况，恰如： 4.1 路径 0 -> -1 -> 1 -> -1 -> -3 所需初始生命为 3 + 1 4.2 路径 0 -> -2 -> 6 -> -1 -> -3 所需初始生命为 2 + 1 4.3 显然路径 4.2 更优，但在正向动规过程中会选择 4.15. 所以我们使用反向动规 ？我们可以避免以上的情况6. 状态转移

1.整体框架1.1定义dp数组// i 表示第i天 // k表示可以操作的次数 // 0 表示不持有股票， 1 表示持有股票// 一定要记仔细定义，不过我相信你会经常来这里看的dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]) max(选择 rest 选择 sell )解释：今天我没有持有股票，有两种可能：要么是我昨天就没有持有，然后今天选择