leetcode C++

1.hashtable

        unordered_map<int, int> hashtable;
            auto it = hashtable.find(target - nums[i]);
            if (it != hashtable.end()) {
                return {it->second, i};
            }
            hashtable[nums[i]] = i;

2.链表的首尾指针
3.滑动窗口，set

unordered_set<char> sub;
	sub.erase(s[i-1]);
    while(r + 1 < n && !sub.count(s[r+1])) 

4.二分查找，找第k小个数

475.二分法

                while(l<r){
                    int mid=(l+r)/2;
                    if(heaters[mid]<houses[i])  {
                        l=mid+1;
                        }
                    else { 
                        r=mid;
                        }
                }

5.dp

        vector<vector<int>> dp(n, vector<int>(n));

7.整数反转
数学知识溢出判断：rev < INT_MIN / 10 || rev > INT_MAX / 10
反转方法：% /
1705.优先级队列

        priority_queue<pii, vector<pii>, greater<pii>> pq;
        pq.emplace(rottenDay, count);

???.中序前序求二叉树
递归实现：

#include <iostream>
using namespace std;
Class recoverybitree{
public:
    ListNode* recovery(ListNode& preorder, ListNode& inorder) {
        if(inorder==null) {
            return nullptr;
        }
        ListNode* cur = new ListNode(preorder);
        ListNode* mid = find(pre in inorder);
        ListNode* left_inorder = ListNode(inorder, mid);
        ListNode* right_inorder = ListNode(mid, inorder.last);
        ListNode* left_preorder = ListNode(preoder+1; preorder+1+left_nodes+1)
        ListNode* right_preorder = ListNode(preorder+1+left_nodes+1, preorder.last)
        cur->left = recovery(left_preorder,left_inorder);
        cur->right = recovery(right_precorde, right_inorder);
        
        
    }
}
int main() {
    //int a;
    //cin >> a;
    cout << "Hello World!" << endl;
}

非递归实现：

二维数组的定义：
vector<vector> dp(n,vector(n));

数字0-9 char转化成int：
cur = n[i]-‘0’;

to_string() 将int转化为string；

#include<bits/stdc++.h> 头文件

vector<vector> dp(n+1,vector(sum+1,0));
初始赋值0；

deque deq;
deq.push_back(n);
deq.pop_front();

int a[26]={2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,9,9,9,9};

当题目中出现 “所有组合” 等类似字眼时，我们第一感觉就要想到用回溯。

需要排序的题可以尝试用一下双指针。

17.回溯 DFS

18.排序+双指针

19.考虑边界情况，删除头指针
双指针 first second

20.栈 + map

373.优先队列：二分查找
23. 合并链表时有一个为空后 p->next = l1 == nullptr ? l2 : l1;
申明空链表 ListNode *ans = nullptr;
优化：分治法

ListNode* merge(vector <ListNode*> &lists, int l, int r) {
    if (l == r) return lists[l];
    if (l > r) return nullptr;
    int mid = (l + r) >> 1;
    return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
}

ListNode* mergeKLists(vector<ListNode*>& lists) {
    return merge(lists, 0, lists.size() - 1);
}

	优先级队列

24.直接修改的话，注意指针不能乱
25.反转链表

pair<ListNode*, ListNode*> myReverse(ListNode* head, ListNode* tail) {
        ListNode* prev = tail->next;
        ListNode* p = head;
        while (prev != tail) {
            ListNode* nex = p->next;
            p->next = prev;
            prev = p;
            p = nex;
        }
        return {tail, head};
    }

200. 1219. DFS

class Solution {
public:
    int m, n, d[4][2] ={{-1,0},{1,0},{0,-1},{0,1}};
    int DFS(vector<vector<int>>& grid, int x, int y, int s) {
        if(x<0 || x>=m || y<0 || y>=n || !grid[x][y])
            return s;
        int t = grid[x][y], Max = 0;
        grid[x][y] = 0;
        for(int i = 0; i < 4; i++) {
            Max = max(Max, DFS(grid, x+d[i][0], y+d[i][1], s+t));
        }
        grid[x][y] = t;
        return Max;
    }
    int getMaximumGold(vector<vector<int>>& grid) {
        m = grid.size();
        n = grid[0].size();
        int Max = 0;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j  < n; j++) {
                if(grid[i][j])  
                    Max = max(Max, DFS(grid, i, j, 0));
            }
        }
        return Max;
    }
};

398.随机数

class Solution {
    unordered_map<int, vector<int>> index;
public:
    Solution(vector<int>& nums) {
        for(int i = 0; i < nums.size(); i ++) {
            index[nums[i]].push_back(i);
        }
    }
    
    int pick(int target) {
        auto &indices = index[target];
        return indices[rand() % indices.size()];
    }
};

347.topk 堆

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        vector<int> ret;
        unordered_map<int, int> mp;
        priority_queue<pair<int, int>> pq;
        for (auto i : nums) mp[i]++;
        for (auto p : mp) {
            pq.push(pair<int, int>(-p.second, p.first));
            if (pq.size() > k) pq.pop();
        }
        while (k--) {
            ret.push_back(pq.top().second);
            pq.pop();
        }
        return ret;
    }
};

347 桶排序

vector<int> topKFrequent(vector<int>& nums, int k) {
	unordered_map<int, int> counts;
	int max_count = 0;
	for (const int & num : nums) {
		max_count = max(max_count, ++counts[num]);
	}
	vector<vector<int>> buckets(max_count + 1);
	for (const auto & p : counts) {
		buckets[p.second].push_back(p.first);
	}
	vector<int> ans;
	for (int i = max_count; i >= 0 && ans.size() < k; --i) {
		for (const int & num : buckets[i]) {
			ans.push_back(num);
			if (ans.size() == k) {
				break;
			}
		}	
	}
	return ans;
}

300

//lower_bound >= key 的第一个数, upper_bound > key的第一个数
auto itr = lower_bound(dp.begin(), dp.end(), nums[i]);
*itr = nums[i]

线段树

并查集