qq_41033011的博客

判断一棵树是否是平衡二叉树OJ 地址：判断一棵树是否是平衡二叉树/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:

合并两个有序数组的中位数OJ地址：合并两个有序数组的中位数因为要求O(log(m+n))，所以第一反应时用二分来找，但是该怎么用二分呢？数组A,B分别有序，我们可以先找到数组A中的一条分界线i，使得数组A分为A_left,和A_right两部分，那么因为时要找到中位数，我们可以直接计算出B数组的一条分界线j，使得size(Aleft)+size(Bleft)=size(Aright)+size(Bright),但此时还没有结束，因为还要满足max(aleft,bleft)<min(arigh

按摩师OJ 地址：按摩师解题思路对于每个预定可以有接收和不接收两种模式can 为接收第 n 个数的最大值，它等于 (不接收上一个的最大值 + 这个的时间的长) 和 (接受上一个的最大值) 的最大值。cannot 为不接受第 n 个数的最大值，它等于（接受第 n-1 个数的最大值）和（不接受第 n-1 的最大值）的最大值。class Solution {public: int massage(vector<int>& nums) { int

硬币面值组合问题具体解题分析可见这篇博客硬币面值组合问题#include <iostream>#include <vector>using namespace std;int coinConbintions(vector<int> &coins, int sum){ int kind = coins.size(); vector<vector<int> > dp(kind + 1, vector<int&

最长上升子序列OJ 地址：最长上升子序列详细解法见这篇博客：最长上升子序列class Solution {public:// int lengthOfLIS(vector<int>& nums) { int n=nums.size(); if(n <= 1) return n; //tail[i]表示长度为i的递增序列末尾的数字 //tail[]数组性质：tail[0]<tail[1]<.

课程表OJ 地址：课程表class Solution { public: bool canFinish(int numCourses, vector<vector<int>>& prerequisites) { vector<vector<int> > neighbor(numCourses); // 相当于构建邻接表 vector<int> in(numCourses, 0);

节点间通路OJ 地址：节点间通路【邻接表+ dfs】class Solution {public: bool findWhetherExistsPath(int n, vector<vector<int>>& graph, int start, int target) { vector<vector<int> > neighbor(n); // 构建邻接表 for(auto it : g

用两个栈实现队列OJ 地址：用两个栈实现队列class Solution{public: void push(int node) { stack1.push(node); } int pop() { if(stack2.empty()) { if(stack1.empty()) return -1; else {

题目：给你一趟旅行中所有的车票信息，请用程序找出旅行线路。比如有车票<大连，北京>, <哈尔滨，大连>, <北京，深圳>，则可以推测路线为<哈尔滨，大连，北京，深圳>。#include <iostream>#include <vector>#include <unordered_map>#include <map>using namespace std;vector<string> Se

二叉树的最大路径和OJ 地址：二叉树的最大路径和/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: int maxPath(TreeNode *node, int &maxSum) { if(node == nullptr) retur

两个链表生成相加链表OJ 地址：两个链表生成相加链表/** * struct ListNode { * int val; * struct ListNode *next; * }; */class Solution {public: /** * * @param head1 ListNode类 * @param head2 ListNode类 * @return ListNode类 */ ListNode* hel

合并两个有序数组OJ 地址：合并两个有序数组class Solution {public: void merge(int A[], int m, int B[], int n) { int index = n + m - 1; int ia = m - 1, ib = n - 1; int i; for(i = index; i >= 0 && ia >= 0 && ib >=

二分查找OJ 地址：二分查找class Solution {public: /** * 二分查找 * @param n int整型 数组长度 * @param v int整型 查找值 * @param a int整型vector 有序数组 * @return int整型 */ int upper_bound_(int n, int v, vector<int>& a) { // write

删除链表的倒数第n个节点OJ 地址：删除链表的倒数第n个节点/** * struct ListNode { * int val; * struct ListNode *next; * }; */class Solution {public: /** * * @param head ListNode类 * @param n int整型 * @return ListNode类 */ ListNode* removeNth

最长的括号子串OJ 地址：最长的括号子串方法一：暴力破解括号要是有效的，必定是成对出现的。比如一个长度为 7 的字符串，我们可以先以 6 个字符为窗口进行滑动判断，如果 6 个字符没有匹配的，再以 4 个字符为窗口进行滑动判断。但是要超时。bool isMatch(string str){ stack<char> s; for(int i = 0; i < str.size(); i++) { if(str[i] == '(')

数组中相加和为0的三元组OJ 地址：数组中相加和为0的三元组/** * （1）首先对数组进行排序（从小到大） * （2）依次取出第 i 个数（i从0开始），并且不重复的选取（跳过重复的数） * （3）这样问题就转换为 2 个数求和的问题（可以用双指针解决方法） * 2 数求和问题 * （4）定义两个指针：左指针（left） 和 右指针（right） * （5）找出固定 left， 此时left所指的位置为数组中最小数，再找到两个数和 不大于 target 的最大 righ

合并k个有序链表OJ 地址：合并k个有序链表方法一：使用优先队列class Solution {public: ListNode* mergeKLists(vector<ListNode*>& lists) { priority_queue<ListNode*, vector<ListNode*>, compare> q; for (auto l : lists) { if (l) {

寻找第K大的数OJ 地址：寻找第K大的数方法一：快排class Finder {public: int quickSort(vector<int>& arr, int l, int r, int n, int k) { if(l >= r) return arr[l]; int v = arr[l]; int i = l + 1; int j = r; while

求平方根OJ 地址：求平方根【二分法】class Solution {public: /** * * @param x int整型 * @return int整型 */ int sqrt(int x) { // write code here long long l, r, m; l = 0; r = x; while(l <= r) {

设计 LRU 缓存结构OJ 地址：设计 LRU 缓存结构#include <unordered_map>class Solution {private: // 维护一个有序单向链表，当有一个新的数据被访问时，从链表头部开始遍历链表： // 1 如果此数据之前已经在缓存中了，那么将其从原来的位置删除，并将其插入到头节点 // 2 如果此数据之前不在缓存中： // 2.1 如果缓存未满，则直接将此节点插入到头节点 // 2.2 如果缓存已满

实现二叉树的三种遍历OJ 地址：实现二叉树的三种遍历void dfs(TreeNode *root, vector<vector<int>> &res) { if(root) { res[0].push_back(root->val); dfs(root->left, res); res[1].push_back(root->val);

最大连续 1 的个数OJ 地址：最大连续 1 的个数int findMaxConsecutiveOnes(vector<int>& nums) { int one = 0, count = 0; int i = 0; for(int i = 0; i < nums.size(); i++) { if(nums[i] == 1) one++;

旋转矩阵OJ 地址：旋转矩阵vector<vector<int> > rotateMatrix(vector<vector<int> > mat, int n) { // write code here vector<vector<int> > res(n, vector<int>(n, 0)); for(int i = 0; i < n; i++)

题目：给你一趟旅行中所有的车票信息，请用程序找出旅行线路。比如有车票<大连，北京>, <哈尔滨，大连>, <北京，深圳>，则可以推测路线为<哈尔滨，大连，北京，深圳>。#include <iostream>#include <vector>#include <unordered_map>#include <map>using namespace std;vector<string> Se

笔记草稿地址：笔记草稿注意：这里需要考虑多括号的问题。#include <iostream>#include <stack>#include <string>using namespace std;string showString(string &str){ string res; for(int i = 0; i < str.size(); i++) { stack<char> s;

字符串分割OJ 地址：字符串分割#include <iostream>#include <vector>using namespace std;void print(string str){ if(str.size() < 8) // 字符串长度小于8，填充0 { int n = 8 - str.size(); for(int i = 0; i < n; i++) str += '0

计算字符个数OJ 地址：计算字符个数#include <iostream>#include <unordered_map>using namespace std;int main(){ string str; char c; getline(cin, str); cin >> c; unordered_map<char, int> m; for(int i = 0; i < str.size(

最小编辑代价OJ 地址：最小编辑代价int minEditCost(string str1, string str2, int ic, int dc, int rc) { // write code here vector<vector<int> > dp(str1.size()+1, vector<int>(str2.size()+1, 0)); for(int i = 1; i <= str2.size();

24点运算OJ 地址：24点运算![在这里插入图片描述](https://img-blog.csdnimg.cn/20200825145020644.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMD#include <iostream>#include <map>using namespace st

24点游戏算法OJ 地址：24点游戏算法#include <iostream>#include <algorithm>using namespace std;bool ret = false;void count24(int index, int curRes, int num[]){ if(curRes == 24) { ret = true; return; } if(ret || curRes &g

跳跃游戏OJ地址：跳跃游戏贪心算法设想一下，对于数组中的任意一个位置 y，我们如何判断它是否可以到达？根据题目描述，只要存在一个一个位置 x，它本身可以到达，并且它跳跃的最大长度为 x+nums[x]，这个值大于等于 y，即 x+nums[x] >= y，那么位置 y 也可以到达。换句话说，对于每一个可以到达的位置，它使得 x+1，x+2，……，x+nums[x] 这些连续的位置都可以到达。这样一来，我们依次遍历数组中的每一个位置，并实时维护最远可以到达的位置。对于当前遍历到的位置 x

买卖股票的最佳时机IIOJ地址：买卖股票的最佳时机II方法一：贪心算法从第 i 天（这里 i >= 1）开始，与第 i - 1 的股价进行比较，如果股价有上升（严格上升），就将升高的股价（ prices[i] - prices[i- 1] ）记入总利润，按照这种算法，得到的结果就是符合题意的最大利润。这道题 “贪心” 的地方在于，对于 “今天的股价 - 昨天的股价”，得到的结果有 3 种可能：（1）正数（2）0（3）负数。贪心算法的决策是：只加正数。int maxProfit(vect

平衡字符串OJ地址：平衡字符串【方法】贪心算法用一个 balance 来记录遍历过的字符串是否平衡，用一个 count 变量记录当前得到的平衡字符串的个数当遍历字符为 ‘L’ 时，balance + 1；当遍历字符为 ‘R’ 时，balance - 1；当 balance == 0时，说明该字串为平衡字符串，那么 count + 1 int balancedStringSplit(string s) { if(s.length() == 0) retu

字符串转成回文串题目解析：当字符串X是一个回文串时，在X两边各添加一个字符’a’后，aXa仍然是一个回文串状态定义F(i, j)：表示字符串的第 i 个字符到第 j 个字符构成回文串所需要添加的最少的字符数。状态分析：当 s[i] == s[j] 时，那么去掉第 i 个字符和 第 j 个字符，它们也需要构成回文串，此时 F(i, j) = F(i+1, j-1)（这里需要明确一点，当i+1 > j-1时也是有意义的，它代表的是空串，空串也是一个回文串，所以这种情况下为 0）当 s

小朋友过桥题目描述：假如有4个小朋友要过桥，它们的过桥时间分别为 1 2 5 10。求他们的最小过桥时间。【步骤】现由1号和2号过桥，花费时间为2，然后1送手电筒回来，花费时间1再由3号和4号过桥。花费时间为10，然后再由2号送手电筒回来，花费时间2最后，1和2一起过桥，花费时间2。最后总时长 = 2 + 1 + 10 + 2 + 2 = 17状态定义：F(i)：前 i 个小朋友过河所需的最短时间状态分析：桥这头只有第 i 个小朋友等待过桥，桥另一头有 前 i-1 个小朋

钢条分割int cut(vector<int> p, int n){ if(n == 0) return 0; int maxValue = 0; for(int i = 1; i <= n && i < p.size(); i++) { maxValue = max(maxValue, p[i-1] + cut(p, n-i)); } return maxValue;}

distinct-subsequencesOJ地址：distinct-subsequences【举个栗子】"rabbbit" —> {rabb, it} {ra, bbit} {rab, bit}一共三种【问题】S中与T相同的子序列的个数【子问题】S的子串中与T相同的子序列的个数【状态】F(i, j)：S的前 i 个字符构成的子串中与T的前 j 个字符相同的子序列的个数如果 S[i] == T[j]：有两种情况【1】如果使用第 i 个字符，那么第 i 个字符必定是作

edit-distanceOJ地址：edit-distance【方法】动态规划【状态】子状态：word1 的前1，2，3……m个字符转换成word2的前1，2，3……n个字符需要的操作次数F(i, j)：word1的前 i 个字符转换成 word2 的前 j 个字符需要的最少操作次数【状态递推】F(i, j) 可由以下三个状态变换而成F(i-1, j) --> F(i, j)F(i-1, j)表示w1的前 i-1 个字符转换成w2的前 j 个字符最少需要F(i

回文串分割OJ地址：回文串分割[动态规划]状态：子状态：到第 1，2，3，……，n个字符需要的最小分割数F(i)：到第 i 个字符需要的最小分割数状态递推：F(i) = min(F(i), F(j) + 1) (当 i < j && [j+1, i]是回文串)上式表示如果从 j+1 到 i 判断为回文串，且已经知道从第 1 个字符到第 j 个字符的最小切割数，那么只需要再切一次，就可以保证 1–>j, j+1 --> i 都是回文串初始化：F(i

背包问题OJ地址：背包问题【思路】定义状态：f[i][j] ：从前 i 个商品中选择，包的大小为 j 时的最大价值定义转化方程（1）当 j >= A[i] ，可以放入: f[i][j] = max(f[i][j - A[i]] + V[i],f[i - 1][j])（2）当 j < A[i] ，放不下： f[i][j] = f[i-1][j]初始化，因为在放0件物品和容量为j时是没有价值的，dp[0][j] = 0int backPackII(int m, vecto