Hillbox

动态规划来做。

用栈的思想。

链表、双指针。主要是删除头结点情况的考虑。

啊，一定情况下，回溯=dfs+剪枝。

为了数组越界的bug花费了好长时间。

最开始用暴力法，果然不通过。看了题解，用双指针。指针移动的时候，如果移动较高边，则x在减小，较高边要么更高、要么不变、要么更矮，三种情况都无法使面积增大。而如果移动较矮边，则x虽也在减小，但较矮边要么更高、要么不变、要么更矮，更高的情况就使之面积增大，因此移动更矮边还有增大面积的可能。.........

先是分情况来做的。然而忘记考虑*的扩张不是无限扩张的。还是得用动态规划来做。然后我看了题解里面非常好的视频，简直太妙咯。看后自己写出来了。

动态规划来填表！分几步。第一步：检验填表顺序对不对打印结果：（表明填表顺序是对的）第二步：开始填表

看了答案，用动态规划做。

输入：l1 = [2，4，3]，l2 = [5，6，4]输出：[7，0，8]题意：输入两个链表，计算链表逆序相加的结果的逆序。即342 + 465 = 807.class Solution {public: ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { // 进位数 int m = 0; // 结果链表的头尾指针 ListNode *head=nullpt.

1、自己做的先合并两个vector，再找出中位数。class Solution {public: double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) { double result; vector<int> nums3; nums3.resize(nums1.size()+nums2.size());

输入：num = 1994输出："MCMXCIV"题意：将整数转罗马数字。罗马数字I-1，V-5，X-10，L-50，C-100，D-500，M-1000，除了这些数之外，其他数就由这些数表示，如II-2，XXVII-27，LIV-54。1、企图用哈希表来做只能枚举了。class Solution {public: string intToRoman(int num) { string result; unordered_map<.

输入：s = "abcdecb"输出：5题意：从字符串s中找出最长的、没有重复字符的子串，返回该子串的长度。1、暴力法2、滑动窗口所写方法比官法答案要快一点点。class Solution {public: int lengthOfLongestSubstring(string s) { int max = 0; vector<char> vec; for(char i : s){ a.

1、用mapclass Solution {public: int longestPalindrome(string s) { int result=0, single=0; unordered_map<char, int> map; for(int i=0; i<s.size(); i++){ map[s[i]]++; } for(auto it=map.begin()

1、一开始先存t，再检查s，这样会多遍历一次。改成先存s，再检查t。class Solution {public: char findTheDifference(string s, string t) { vector<int> vec(26, 0); for(int i=0; i<s.size(); i++){ vec[s[i]-'a']++; } for(int i=0; i<

1、用mapclass Solution {public: int firstUniqChar(string s) { unordered_map<char, int> map; for(int i=0; i<s.size(); i++){ map[s[i]]++; } for(int i=0; i<s.size(); i++){ if(map[s[i]]=

1、用map做class Solution {public: bool canConstruct(string ransomNote, string magazine) { unordered_map<char, int> map; for(int i=0; i<magazine.size(); i++){ map[magazine[i]]++; } for(int i=0; i<

1、一开始没读懂题意。就是相对于上一题不能重复输出数字，这一题就是把重复的数字也输出。要用到map。class Solution {public: vector<int> intersect(vector<int>& nums1, vector<int>& nums2) { unordered_map<int, int> map; vector<int> result;

1、两个set来做class Solution {public: vector<int> intersection(vector<int>& nums1, vector<int>& nums2) { unordered_set<int> hash1, hash2; vector<int> result; for(int i=0; i<nums1.size(); i

1、我的想法。跟之前205同构字符串的思路类似。class Solution {public: bool wordPattern(string pattern, string str) { int i = 0, pre = 0; string::size_type pos; string temp; unordered_map<char, string> hash1; unordered_map&lt

1、这题tmd有点读不懂。后面才知道，比如数组长度是10，那么里面应该包含0到10的数字，如果某些数字没包含，就把它们输出。这个用数组来做倒是很好办，但是要遍历一次次原数组和后面创建的数组。本以为没有官方答案快，但是是差不多的。class Solution {public: int missingNumber(vector<int>& nums) { int len = nums.size(); int arr[len+1];

1、用ordered_map做出来了class Solution {public: bool isAnagram(string s, string t) { if(s.size() != t.size()){ return false; } unordered_map<char, int> hashtable; for(int i=0; i<s.size(); i++){

1、一开始理解错题意了，没写对。理解题意之后感觉混乱，因为知道哈希表装的是数和数对应的下标。同一个数不能重复，那么存的下标是最早遍历到的还是当前遍历到的呢。这点没想通，后面看了题解发现人家存的下标就是最新的。想想也是，之前遍历到的数不符合规则了，丢弃就是了。class Solution {public: bool containsNearbyDuplicate(vector<int>& nums, int k) { unordered_map<int

1、用set做，太简单class Solution {public: bool containsDuplicate(vector<int>& nums) { unordered_set<int> hashtable; for(int i=0; i<nums.size(); i++){ if(hashtable.count(nums[i])){ return true;

1、自己写的，想的复杂了，也知道肯定有更好的办法，想不出来class Solution {public: bool isIsomorphic(string s, string t) { int index1 = 0, index2 = 0; int now1, now2; unordered_map<char, int> hashtable1, hashtable2; for(int i=0; i<s.size

1、想不到怎么用上哈希表，结果发现判断无限循环的时候要用到！class Solution {public: bool isHappy(int n) { int sum = n; unordered_set<int> hashtable; string str; while(sum != 1){ str = to_string(sum); if(hashtable.cou

1、肯定是用unordered_map啦！class Solution {public: int majorityElement(vector<int>& nums) { unordered_map<int, int> count; int max_count=0, max_num=0; for(int num: nums){ count[num]++; if(co

1、用昨天学到的unordered_set来做！成功！把A表装到set中，再遍历B表去set里找有没有重复的。class Solution {public: ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { unordered_set<ListNode*> hashtable; for(;headA!=NULL; headA=headA->next){

1、想着用unordered_map来做，key是结点的数值val，value是设置的自己加的index，但是val是可能重复的，而index一直都在变，不可能判断出已经访问过的结点，结果就是找不到魂头！2、官方用unordered_set来做，之前不知道这个东西，针不戳！不像map需要键值对，set只有一个参数。class Solution {public: bool hasCycle(ListNode *head) { unordered_set<ListNod

1、用hashtableclass Solution {public: int romanToInt(string s) { int result = 0; string temp; unordered_map<string, int>hashtable{ {"I", 1}, {"V", 5}, {"X", 10}, {"L", 50}, {"C", 100}, {"D", 500},

1、暴力法双重遍历，笨办法，舍弃。2、运用C++的STL库的find函数遍历数组一次，每遍历到一个数，就用target减去该数得到一个差，去数组未遍历的部分用stl方法查找有没有这个差。找到了就输出。class Solution {public: vector<int> twoSum(vector<int>& nums, int target) { vector<int> result; vector&l