ChasingTheFreeWind

题目如果了解动态规划经典题目LIS（最长递增子序列）问题，那么读完这个题应该就能知道这个题其实质是让我们找信封长宽数组对的最长递增子序列。不过还有一点不同的是，LIS问题中，子序列是选取一些元素后按其原有的相对序列排列的。而这个问题中，“子序列”在选取部分元素后，并不是按其原来的相对顺序排列的，而是按照大小排列。所以，我们可以先把这个二维数组转化一下，对它排个序，它的宽由小到大排列。那长应该如何排列呢？我们看一下对[(5, 4), (6, 4), (6, 7), (2, 3)]长由大到小排列: (2

思路似乎是个经典题目思路就是一个递归/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; thi.

LRU算法应该对所有计算机\软工的同学都不陌生了。那么要如何实现LRU算法呢？LRU算法需要设计一个数据结构，这个数据结构有两个操作，一个是get(key)：获取key对应的value，如果key不存在则返回-1put(key, value): 存入键值对以上两个操作的复杂度都应该为O(1)分析上述操作，总结这个数据结构的必要条件为：查找快、插入块、删除快、有序哈希表查找快，但无序链表有顺序，但查找慢，结合形成哈希链表。可以写下以下代码代码class Node{ Node pr

题目链接dfs枚举所有子序列和一个长度为n的数组的所有子序列和的个数为2^n对于每一个元素，有选/不选两种情况由于问题给的数组长度最大为40，如果直接对整个数组求所有子序列和则最大时间复杂度级别达到2^40，于是可以将问题转换为求左半边和右半边数组的所有子序列和。然后对左半数组从小到大排序，右半数组从大到小排序，最后用双指针技巧解决问题。代码class Solution {public: vector<int> left, right; int cnt1 = 0;

温故而知新嘛！其实讲道理，这个编辑距离其实蛮简单的啊！class Solution { public int minDistance(String word1, String word2) { int N = word1.length(); int M = word2.length(); if(N==0) return M; if(M==0) return N; in

打家劫舍系列问题打家劫舍一思路显然，对于每家小偷都有打或不打两种情况，用dp[i][j]表示前i家小偷打劫的最大收益,并用j标记是否打劫第i家,于是很容易想到如下递推式：dp[i][0] = max(dp[i-1][0], dp[i-1][1]);dp[i][1] = max(dp[i-1][0], dp[i-2][1]) + nums[i]该式子又可以简化一下：dp[i] = max(dp[i-1], dp[i-2] + nums[i])class Solution { publ

递推式6个问题全解决dp[i][j][k]: 第i天 至多k次交易 (0无1有)dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + price[i])dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - price[i]) 买入时认为是一次交易dp[-1][k][0] = 0dp[-1][k][1] = -INF //第-1天不可能有股票dp[i][0][0] = 0;dp[i][0][1

1. 能否连接形成数组哈希表其实比赛时第一题还想了好一会儿。其实这题思路很简单，用一个哈希表保存一维数组各个数字的位置。然后遍历二维数组pieces，然后对于pieces的每一个数组，判断该数组的值是否在一维数组中，是否在一维数组的位置是连续的即可。class Solution {public: bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {

前两题略3. 最小体力消耗路径参考链接dijkstra优化#define INF 0x3f3f3f3fstruct Dist{ int x,y,z; Dist(int _x, int _y, int _z):x(_x), y(_y), z(_z){} bool operator < (const Dist& A) const { return z > A.z; } };class Solution {public:

一、数组剑指Offer 03.数组中重复的数字思路运用了类似桶排序的思想。因为数字在0~n-1内，于是可以将值为x的元素放在下标为x的位置，如果放置时发现数组中下标为x的元素值已经是x了，则就找到了一个重复元素。时间复杂度O(n)空间复杂度O(1)代码class Solution {public: int findRepeatNumber(vector<int>& nums) { int i = 0; int N = nums.s

剑指Offer剑指Offer 06.从尾到头打印链表栈/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: vector<int> reversePrint(ListNo

1. 特殊数组的特征值思路懒得思考，直接暴力代码class Solution {public: int specialArray(vector<int>& nums) { for(int i=1;i<1010;i++) { int cnt = 0; for(int j=0;j<nums.size();j++) { if(nu

1.重新排列单词间的空格代码class Solution {public: string reorderSpaces(string text) { int N = text.length(); int cnt = 0; for(int i=0;i<N;i++) { if(text[i]==' ') cnt++; } istringst

1. 二进制矩阵中的特殊位置代码class Solution {public: int numSpecial(vector<vector<int>>& mat) { int N = mat.size(); int M = mat[0].size(); vector<int> sumi(N); vector<int> sumj(M); for(int i=0

1. 替换所有的问号代码1class Solution {public: string modifyString(string s) { int N = s.length(); if(s[0]=='?') { for(int p = 'a'; p<='z'; p++) { if(s[1]!=p) {

1.重复至少k次且长度为M的模式class Solution {public: bool containsPattern(vector<int>& arr, int m, int k) { int N = arr.size(); for(int i = 0; i + k * m <= N; i++) { bool flag = true; for(int j = i; j

1. 整理字符串思路代码1暴力class Solution {public: string makeGood(string s) { int N = s.length(); string ans = s; while(1) { N = ans.length(); string tmp = ""; bool flag = false;

可以说本次周赛是最近几次最最最简单的了。。。但是依然表现不佳，写的时候甚至感觉手有些生疏了。算法思路都是有的，但是总是没有想得很清晰完善，于是就是“答案错误”。1.统计好三元组暴力代码class Solution {public: int countGoodTriplets(vector<int>& arr, int a, int b, int c) { int N = arr.size(); int ans = 0;

1. 重新排列字符串class Solution {public: string restoreString(string s, vector<int>& indices) { map<int,int> pos; string str; int n = indices.size(); for(int i=0;i<n;i++) { pos[indices[

微软专场，较为困难1. 换酒问题class Solution {public: int numWaterBottles(int numBottles, int numExchange) { int remains = numBottles; int ans = remains; while(remains>=numExchange) { //ans += remains; i

1. 判断能否形成等差数列class Solution {public: bool canMakeArithmeticProgression(vector<int>& arr) { if(arr.size()<=1) return true; sort(arr.begin(),arr.end()); int diff = arr[1] - arr[0]; for(int i=1;i

1. 好数对的数目思路直接暴力代码class Solution {public: int numIdenticalPairs(vector<int>& nums) { int N = nums.size(); if(N<1) return 0; int ans = 0; for(int i=0;i<N;i++) { for(int

5448.判断路径是否相交集合查找class Solution {public: bool isPathCrossing(string path) { set<pair<int,int>> s; int curx = 0; int cury = 0; s.insert(make_pair(curx,cury)); for(int i=0;i<path.length();i++)

一直忘了更新周赛挺难先更钱两题1. 数组异或操作class Solution {public: int xorOperation(int n, int start) { int ans = 0; for(int i=0;i<n;i++) { ans ^= start+2*i; } return ans; }};2. 保证文件名唯一class Solution {

1. 一位数组的动态和class Solution {public: vector<int> runningSum(vector<int>& nums) { vector<int> sum; int N = nums.size(); sum.resize(N); sum[0] = nums[0]; for(int i=1;i<N;i++) {

题目链接递归自顶向下的思路class Solution {public: bool judge(string s1, string s2) { if(s1==s2) return true; int N = s1.length(); string t1 = s1; string t2 = s2; sort(t1.begin(),t1.end()); sort(t2.

很简单的一个动态规划class Solution {public: int translateNum(int num) { stringstream ss; ss<<num; string s = ss.str(); int N = s.length(); vector<int> dp; dp.resize(N+1); dp[0] = 1; d.

class Solution {public: map<int,int> father; int Find(int x) { int r = x; while(father[r]!=r) r = father[r]; int i = x; int j; while(father[i]!=i) { j = father[i];.

这周周赛发挥不佳1. 重新排列数组class Solution {public: vector<int> shuffle(vector<int>& nums, int n) { vector<int> ans; for(int i=0;i<n;i++) { ans.push_back(nums[i]); ans.push_back(nums[i+n]

并查集思路并查集，遍历数组，如果该数字+1在数组中则将它们合并。代码class Solution { unordered_map<int,int> father,cnt; int Find(int x) { int r = x; while(r!=father[r]) { r = father[r]; } int i = x; int j; .

class Solution {public: vector<int> spiralOrder(vector<vector<int>>& matrix) { vector<int> ans; int N = matrix.size(); if(N==0) return ans; int M = matrix[0].size(); int .

复习期末了，这周周赛水一水1. 数组中两元素的最大乘积代码class Solution {public: int maxProduct(vector<int>& nums) { int N = nums.size(); sort(nums.begin(),nums.end()); return (nums[N-1]-1)*(nums[N-2]-1); }};2. 切割后面积最大的蛋糕代码const in

代码dp[i] = dp[i-1] + dp[i-2] ((s[i-2]-‘0’)*10+s[i-1])dp[i] = dp[i-1] others这题还需要注意0的判定。。。"01"的答案是0，"10"的答案是1class Solution {public: int numDecodings(string s) { int N = s.length(); if(s[0]=='0') .

纪念第一次"AK"（12:02 AK。。。最后一题太蠢了 这么简单个动态规划，找bug找了很久）leetcode最近周赛好像越来越简单了啊，最后一题的动态规划也不难。1. 检查单词是否为句中其他单词的前缀代码class Solution {public: int isPrefixOfWord(string sentence, string searchWord) { istringstream ss(sentence); string word;

这次周赛的题比较暴力，没有涉及什么算法，最后一个题是个数学题。1. 在既定时间做作业的学生人数思路暴力即可代码2. 重新排列句子中的单词思路排序即可代码class Solution {public: static bool cmp(pair<string,int> p1,pair<string,int> p2) { if(p1.first.length()==p2.first.length()) retur

异或操作：任何数异或0得0，任何数异或自己得0。根据这个性质就可在时间复杂度O(N)，空间复杂度O(1)之下求到答案。class Solution {public: int singleNumber(vector<int>& nums) { int single = 0; for(int num:nums) single^=num; return single; }};...

代码class Solution {public: vector<vector<int>> fourSum(vector<int>& nums, int target) { sort(nums.begin(),nums.end()); int N = nums.size(); vector<vector<int>> ans; for(int i=0;i<N;.

class Solution {public: int threeSumClosest(vector<int>& nums, int target) { int N = nums.size(); int mini = 0x3f3f3f3f; int ans = -1; sort(nums.begin(),nums.end()); for(int i=0;i<N;i++) {.

双指针class Solution {public: vector<vector<int>> threeSum(vector<int>& nums) { int N = nums.size(); sort(nums.begin(),nums.end()); vector<vector<int>> ans; for(int i=0;i<N;i++) .

class Solution {public: double quickPow(double x, long n) { double ans = 1.0; double mul = x; while(n) { if(n&1) ans*=mul; mul*=mul; n/=2; } r.