博客搬至blog.csgrandeur.com，cnblogs不再更新。
新的题解会更新在新博客：http://blog.csgrandeur.com/3/
————————————————————————————————————————
————————————————————————————————————————
LeetCode OJ 题解
LeetCode OJ is a platform for preparing technical coding interviews.
LeetCode OJ 是为与写代码有关的技术工作面试者设计的训练平台。
LeetCode OJ:http://oj.leetcode.com/
默认题目顺序为题目添加时间倒叙，本文题解顺序与OJ题目顺序一致（OJ会更新，至少目前一致。。。），目前共152题。
Made By：CSGrandeur
另外，Vimer做了Python版的题解：http://c4fun.cn/blog/2014/03/20/leetcode-solution-02/
————————————————————————————————————————
Maximum Product Subarray
维护当前位置连续乘积的最大值 tmpp 和最小值 tmpn ，最大值和最小值都可能由三种情况得到：上一个数的 tmpp*A[i]，上一个数的 tmpn*A[i]，A[i]本身。
不断更新答案，最终输出。
1 class Solution {
2 public:
3 int maxProduct(int A[], int n) {
4 int tmpp = A[0], tmpn = A[0], tmp, ans = A[0];
5 for(int i = 1; i < n; i ++)
6 {
7 tmp = tmpp;
8 tmpp = max(max(A[i], A[i] * tmpp), A[i] * tmpn);
9 tmpn = min(min(A[i], A[i] * tmp), A[i] * tmpn);
10 ans = max(ans, tmpp);
11 }
12 return ans;
13 }
14 };
先翻转整个字符串，然后从前往后一个单词一个单词地再翻转一次，同时去除多余空格，等于是扫描两遍，O(n)。
1 class Solution {
2 public:
3 void reverseWords(string &s) {
4 reverse(s.begin(), s.end());
5 int start = 0, end = 0, j = 0;
6 while(start != s.length())
7 {
8 while(start != s.length() && s[start] == ' ') start ++;
9 for(end = start; end != s.length() && s[end] != ' '; end ++);
10 if(j != 0 && start <= end - 1) s[j ++] = ' ';
11 for(int i = end - 1; start < i; start ++, i --)
12 swap(s[i], s[start]), s[j ++] = s[start];
13 while(start < end) s[j ++] = s[start ++];
14 }
15 s.resize(j);
16 }
17 };
Evaluate Reverse Polish Notation
逆波兰表达式计算四则运算。用栈。
1 class Solution {
2 public:
3 int evalRPN(vector<string> &tokens) {
4 int a, b;
5 stack<int> s;
6 for(int i = 0; i < tokens.size(); i ++)
7 {
8 if(isdigit(tokens[i][0]) || tokens[i].length() > 1)
9 {
10 s.push(atoi(tokens[i].c_str()));
11 continue;
12 }
13 a = s.top();s.pop();
14 b = s.top();s.pop();
15 switch(tokens[i][0])
16 {
17 case '+': s.push(b + a); break;
18 case '-': s.push(b - a); break;
19 case '*': s.push(b * a); break;
20 case '/': s.push(b / a); break;
21 }
22 }
23 return s.top();
24 }
25 };
Max Points on a Line
平面上一条直线最多穿过多少点。乍一看好熟悉的问题，做了这么久计算几何。。。却还真没做过这个小问题。
第一反应当然不能O(n^3)枚举了，枚举圆周好像也不行，毕竟是考察所有点，不是某个点。那么应该就是哈希斜率了吧。
肯定少不了竖直的线，哈希斜率这不像是这类OJ让写的题吧。。忘了map这回事了。
确定思路之后，还是看看别人博客吧，少走点弯路，然后就学习了还有unordered_map这么个东西，还有一个博客的思路挺好，避免double问题，把斜率转化成化简的x、y组成字符串。
再另外就是重叠的点了，想让题目坑一点，怎能少得了这种数据，单独处理一下。
1 /**
2 * Definition for a point.
3 * struct Point {
4 * int x;
5 * int y;
6 * Point() : x(0), y(0) {}
7 * Point(int a, int b) : x(a), y(b) {}
8 * };
9 */
10 class Solution {
11 public:
12 int maxPoints(vector<Point> &points) {
13 int ans = 0;
14 for(int i = 0; i < points.size(); i ++)
15 {
16 unordered_map<string, int> mp;
17 int tmpans = 0, same = 0;
18 for(int j = i + 1; j < points.size(); j ++)
19 {
20 int x = points[j].x - points[i].x, y = points[j].y - points[i].y;
21 int g = gcd(x, y);
22 if(g != 0) x /= g, y /= g;
23 else {same ++; continue;}
24 if(x < 0) x = -x, y = -y;
25 string tmp = to_string(x) + " " + to_string(y);
26 if(!mp.count(tmp)) mp[tmp] = 1;
27 else mp[tmp] ++;
28 tmpans = max(tmpans, mp[tmp]);
29 }
30 ans = max(tmpans + 1 + same, ans);
31 }
32 return ans;
33 }
34 int gcd(int a, int b)
35 {
36 return a ? gcd(b % a, a) : b;
37 }
38 };
Sort List
又长见识了，原来链表也可以O(nlogn)排序的。没往下想就查了一下，看到人说用归并，于是才开始想能不能实现。。。
O(n)找到中点，把中点的next变成NULL，对两部分递归。递归结束后对两部分归并，先找到newhead，即两部分的头部val较小的那个，然后归并就把小的从newhead往后续。
把最后的next赋值NULL，返回newhead。
又有空数据@_@.
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *sortList(ListNode *head) {
12 int n = 0;
13 ListNode *p = head;
14 while(p != NULL)
15 n ++, p = p->next;
16 if(n <= 1) return head;
17 n >>= 1;
18 p = head;
19 while(-- n)
20 p = p->next;
21 ListNode *tmp = p->next;
22 p->next = NULL;
23 ListNode *nl = sortList(head);
24 ListNode *nr = sortList(tmp);
25 ListNode *newhead;
26 if(nl->val < nr->val)
27 {
28 newhead = nl;
29 nl = nl->next;
30 }
31 else
32 {
33 newhead = nr;
34 nr = nr->next;
35 }
36 p = newhead;
37 while(nl != NULL && nr != NULL)
38 {
39 if(nl->val < nr->val) p->next = nl, p = p->next, nl = nl->next;
40 else p->next = nr, p = p->next, nr = nr->next;
41 }
42 while(nl != NULL) p->next = nl, p = p->next, nl = nl->next;
43 while(nr != NULL) p->next = nr, p = p->next, nr = nr->next;
44 p->next = NULL;
45 return newhead;
46 }
47 };
Insertion Sort List
指针操作很烦啊。。暴力枚举插入位置，注意细节就能过了。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *insertionSortList(ListNode *head) {
12 ListNode *newhead = head;
13 if(head == NULL) return NULL;
14 head = head->next;
15 newhead->next = NULL;
16 while(head != NULL)
17 {
18 if(head->val < newhead->val)
19 {
20 ListNode *tmp = head->next;
21 head->next = newhead;
22 newhead = head;
23 head = tmp;
24 continue;
25 }
26 ListNode *pre = newhead, *p = newhead->next;
27 while(p != NULL && p->val < head->val)
28 {
29 p = p->next;
30 pre = pre->next;
31 }
32 pre->next = head;
33 head = head->next;
34 pre = pre->next;
35 pre->next = p;
36 }
37 return newhead;
38 }
39
40 };
新建数据类class Val，保存key、val和访问自增标记updatecnt。
用unordered_map更新数据，增加updatecnt，并把更新的数据放入队列，最关键是处理capacity满了的时候，队列依次出队，map中不存在的和updatecnt和最新数据不相等的项目都忽略，直到发现updatecnt和map中存的最新状态相等，则为“最近未使用”数据，出队后在map中erase。思路有点像STL队列实现版本的Dijkstra。
有一个博客的方法更好，map中存的是链表的节点指针，链表顺序表示访问情况，这样就把map内容和链表的每个节点一一对应了，没有冗余节点，且更新操作也是O(1)的。
1 class Val{
2 public:
3 int key;
4 int val;
5 int updatecnt;
6 };
7 class LRUCache{
8 public:
9 int cap;
10 unordered_map<int, Val> mp;
11 queue<Val> q;
12 LRUCache(int capacity) {
13 cap = capacity;
14 }
15
16 int get(int key) {
17 if(mp.count(key))
18 {
19 mp[key].updatecnt ++;
20 q.push(mp[key]);
21 return mp[key].val;
22 }
23 return -1;
24 }
25
26 void set(int key, int value) {
27 if(mp.count(key))
28 {
29 mp[key].val = value;
30 mp[key].updatecnt ++;
31 q.push(mp[key]);
32 }
33 else
34 {
35 if(mp.size() == cap)
36 {
37 Val tmp;
38 while(!q.empty())
39 {
40 tmp = q.front();
41 q.pop();
42 if(mp.count(tmp.key) && tmp.updatecnt == mp[tmp.key].updatecnt)
43 break;
44 }
45 mp.erase(mp.find(tmp.key));
46 mp[key].key = key;
47 mp[key].val = value;
48 mp[key].updatecnt = 0;
49 q.push(mp[key]);
50 }
51 mp[key].key = key;
52 mp[key].val = value;
53 mp[key].updatecnt = 0;
54 q.push(mp[key]);
55 }
56 }
57 };
Binary Tree Postorder Traversal
二叉树的非递归后序遍历，考研的时候非常熟悉了，现在写又要想好久。重点是关于右子树遍历时候需要一个标记，或者标记根节点出栈次数，或者标记右子树是否访问。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<int> postorderTraversal(TreeNode *root) {
13 vector<int> ans;
14 if(root == NULL) return ans;
15 stack<TreeNode*> s;
16 TreeNode *visited;
17 while(root != NULL || !s.empty())
18 {
19 while(root != NULL)
20 s.push(root), root = root->left;
21 root = s.top();
22 if(root->right == NULL || visited == root->right)
23 {
24 ans.push_back(root->val);
25 s.pop();
26 visited = root;
27 root = NULL;
28 }
29 else
30 {
31 root = root->right;
32 }
33 }
34 return ans;
35 }
36 };
Binary Tree Preorder Traversal
前序遍历的非递归就容易多了。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<int> preorderTraversal(TreeNode *root) {
13 stack<TreeNode*> s;
14 vector<int> ans;
15 if(root == NULL) return ans;
16 s.push(root);
17 while(!s.empty())
18 {
19 root = s.top();
20 s.pop();
21 ans.push_back(root->val);
22 if(root->right != NULL) s.push(root->right);
23 if(root->left != NULL) s.push(root->left);
24 }
25 }
26 };
Reorder List
找到中间位置，把中间之后的链表反转，两个指针一个从头一个从尾开始互插，奇偶和指针绕得有点晕，理清就好了。。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 void reorderList(ListNode *head) {
12 int n = 0;
13 ListNode *pre, *p = head;
14 while(p)
15 n ++, p = p->next;
16 if(n < 3) return;
17 n >>= 1;
18 pre = p = head;
19 p = p->next;
20 while(n --) p = p->next, pre = pre->next;
21 while(p != NULL)
22 {
23 ListNode *tmp = p->next;
24 p->next = pre;
25 pre = p;
26 p = tmp;
27 }
28 ListNode *tail = pre;
29 p = head;
30 while(true)
31 {
32 ListNode *tmp1 = p->next, *tmp2 = tail->next;
33 p->next = tail;
34 tail->next = tmp1;
35 p = tmp1;
36 if(p == tail || p == tmp2) break;
37 tail = tmp2;
38 }
39 p->next = NULL;
40 }
41 };
设置两个指针slow和fast，从head开始，slow一次一步，fast一次两步，如果fast能再次追上slow则有圈。
设slow走了n步，则fast走了2*n步，设圈长度m，圈起点到head距离为k，相遇位置距离圈起点为t，则有：
n = k + t + pm; (1)
2*n = k + t + qm;(2)
这里p和q是任意整数。（不过fast速度是slow二倍，则肯定在一圈内追上，p就是0了）
2 * (1) - (2) 得k = lm - t;(l = q - 2 * p)
即 k 的长度是若干圈少了 t 的长度。
因此这时候，一个指针从head开始，另一个从相遇位置开始，都每次只走一步，当从head开始的指针走到圈开始位置时，两指针刚好相遇。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *detectCycle(ListNode *head) {
12 if(head == NULL) return NULL;
13 ListNode *slow, *fast;
14 slow = fast = head;
15 int n = 0;
16 do
17 {
18 n ++;
19 if(slow == NULL || fast == NULL) return NULL;
20 slow = slow->next;
21 fast = fast->next;
22 if(fast == NULL) return NULL;
23 fast = fast->next;
24 if(fast == NULL) return NULL;
25 }while(slow != fast);
26 fast = head;
27 while(slow != fast)
28 slow = slow->next, fast = fast->next;
29 return fast;
30 }
31 };
Linked List Cycle
呃，时间逆序做的结果。。。成买一送一了。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 bool hasCycle(ListNode *head) {
12 if(head == NULL) return false;
13 ListNode *slow, *fast;
14 slow = fast = head;
15 int n = 0;
16 do
17 {
18 n ++;
19 if(slow == NULL || fast == NULL) return NULL;
20 slow = slow->next;
21 fast = fast->next;
22 if(fast == NULL) return NULL;
23 fast = fast->next;
24 if(fast == NULL) return NULL;
25 }while(slow != fast);
26 return true;
27 }
28 };
Word Break II
先递推，dp[i] == true 表示 s 中前 i 个字符的串是符合要求的，枚举位置 i ，对于 i 枚举位置 j < i，如果 dp[j] == true且 j ~ i的串在字典中，则dp[i] = true。
同时对于这样的 j, i，site[i].push_back(j)，即在 i 位置的可行迭代表中增加位置 j。
完成site之后，从尾部倒着DFS过去就得到了所有串。
1 class Solution {
2 public:
3 vector<string> DFS(const string &s, vector<int> *site, int ith)
4 {
5 vector<string> res;
6 for(int i = 0; i < site[ith].size(); i ++)
7 {
8 vector<string> tmp;
9 string str = s.substr(site[ith][i], ith - site[ith][i]);
10 if(site[site[ith][i]].size() == 0)
11 res.push_back(str);
12 else
13 {
14 tmp = DFS(s, site, site[ith][i]);
15 for(int j = 0; j < tmp.size(); j ++)
16 res.push_back(tmp[j] + " " + str);
17 }
18 }
19 return res;
20 }
21 vector<string> wordBreak(string s, unordered_set<string> &dict) {
22 vector<int> *site = new vector<int>[s.length() + 1];
23 bool *dp = new bool[s.length() + 1];
24 memset(dp, 0, sizeof(bool) * s.length());
25 dp[0] = true;
26 for(int i = 1; i <= s.length(); i ++)
27 {
28 for(int j = 0; j < i; j ++)
29 {
30 if(dp[j] == true && dict.count(s.substr(j, i - j)))
31 site[i].push_back(j), dp[i] = true;
32 }
33 }
34 return DFS(s, site, s.length());
35 }
36 };
Word Break
参考Word Break II，对于dp标记，当dp[i]为true时候可以停止枚举后面的 j，优化一下常数。
1 class Solution {
2 public:
3 bool wordBreak(string s, unordered_set<string> &dict) {
4 bool *dp = new bool[s.length() + 1];
5 memset(dp, 0, sizeof(bool) * (s.length() + 1));
6 dp[0] = true;
7 for(int i = 1; i <= s.length(); i ++)
8 for(int j = 0; j < i; j ++)
9 {
10 dp[i] = dp[i] || dp[j] && dict.count(s.substr(j, i - j));
11 }
12 return dp[s.length()];
13 }
14 };
Copy List with Random Pointer
第一次遍历，把每个节点复制一份放到对应节点的下一个，即组成二倍长的链表：ori1->copy1->ori2->copy2->....
第二次遍历，利用“复制节点总是对应节点的下一个节点”特性，将每个ori->next->random指向ori->random->next，中间判断一下空指针。
第三次遍历，把两个链表拆开，恢复原链表。
1 /**
2 * Definition for singly-linked list with a random pointer.
3 * struct RandomListNode {
4 * int label;
5 * RandomListNode *next, *random;
6 * RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 RandomListNode *copyRandomList(RandomListNode *head) {
12 RandomListNode *p = head, *newhead = NULL, *tmp;
13 if(p == NULL) return NULL;
14 while(p != NULL)
15 {
16 tmp = new RandomListNode(p->label);
17 tmp->next = p->next;
18 p->next = tmp;
19 p = tmp->next;
20 }
21 newhead = head->next;
22 p = head;
23 while(p != NULL)
24 {
25 tmp = p->next;
26 tmp->random = p->random == NULL ? NULL : p->random->next;
27 p = tmp->next;
28 }
29 p = head;
30 while(p != NULL)
31 {
32 tmp = p->next;
33 p->next = tmp->next;
34 p = tmp->next;
35 tmp->next = p == NULL ? NULL : p->next;
36 }
37 return newhead;
38 }
39 };
Single Number II
方法一：设置cnt[32]记录 32个比特位的1的个数，出现3次的数的对应位的1总数为3的倍数，则统计之后每个位对3取模，剩下的位为1的则对应个数为1的那个数。
1 class Solution {
2 public:
3 int singleNumber(int A[], int n) {
4 int cnt[32] = {0};
5 for(int i = 0; i < n; i ++)
6 {
7 int tmp = A[i];
8 for(int j = 0; j < 33; tmp >>= 1, j ++)
9 cnt[j] += tmp & 1;
10 }
11 int ans = 0;
12 for(int i = 0; i < 32; i ++)
13 ans |= (cnt[i] % 3) << i;
14 return ans;
15 }
16 };
方法二：设置int one, two模拟两位二进制来统计各比特位1次数，每当one和two对应二进制位都为1的时候把one和two都清零，最后剩下的one就是要求的数。
1 class Solution {
2 public:
3 int singleNumber(int A[], int n) {
4 int one = 0, two = 0;
5 for(int i = 0; i < n; i ++)
6 {
7 two |= one & A[i];
8 one ^= A[i];
9 int tmp = one & two;
10 two ^= tmp;
11 one ^= tmp;
12 }
13 return one;
14 }
15 };
一路异或过去就可以了。
1 class Solution {
2 public:
3 int singleNumber(int A[], int n) {
4 int tmp = 0;
5 for(int i = 0; i < n; i ++)
6 tmp ^= A[i];
7 return tmp;
8 }
9 };
Candy
时间复杂度 O(n)的方法还是容易想了，优化为空间复杂度O(1)的话也不难，只是思考代码的时候会有点绕。
上坡一步步来，下坡走个等差数列，波峰位置比较一下上坡时候记录的最大值和下坡求的的最大值，取较大的，具体看代码：
1 class Solution {
2 public:
3 int candy(vector<int> &ratings) {
4 int cnt = 0, i, j, start, nownum;
5 for(i = 0; i < ratings.size(); i ++)
6 {
7 if(i == 0 || ratings[i] == ratings[i - 1])
8 nownum = 1;
9 else if(ratings[i] > ratings[i - 1])
10 nownum ++;
11 if(i + 1 < ratings.size() && ratings[i + 1] < ratings[i])
12 {
13 start = 1;
14 for(j = i + 1; j < ratings.size() && ratings[j] < ratings[j - 1]; start++, j ++);
15 if(start > nownum)
16 cnt += (start + 1) * start >> 1;
17 else
18 cnt += ((start - 1) * start >> 1) + nownum;
19 nownum = 1;
20 i = j - 1;
21 }
22 else
23 cnt += nownum;
24 }
25 return cnt;
26 }
27 };
Gas Station
证明题。
一、如果从 i 到 j 的时候理论计算气量刚好为负数，则 i ~ j 的加气站都不可以作为起点。
反证一下，从前往后去掉站，如果去掉的站能增加气，即正数，则结果更糟。如果去掉的站是负数，那么负数如果抵消了之前的正数，则在到 j 之前已经负数了，如果不能抵消之前的正数，那么结果还是更糟。
二、判断是否能成行，一个环的和为非负就可以。
假设环为正， 0 ~ j 刚好为负， j + 1 ~ k 刚好为负数，k + 1 之后为正，则 k + 1 为答案。
也反证一下，k + 1 出发，到gas.size() - 1都为正，则转回来到 j - 1 都会为正。如果到 j 时候为负，则整个环不可能为正，所以到 j 的时候也为正，剩下的一样。这样就能够成功转一圈。
1 class Solution {
2 public:
3 int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
4 int i, ans, sum, all;
5 for(i = ans = sum = all = 0; i < gas.size(); i ++)
6 {
7 sum += gas[i] - cost[i];
8 all += gas[i] - cost[i];
9 if(sum < 0)
10 {
11 sum = 0;
12 ans = i + 1;
13 }
14 }
15 return all >= 0 ? ans : -1;
16 }
17 };
Clone Graph
label是唯一的，递归，用unordered_map标记。
1 /**
2 * Definition for undirected graph.
3 * struct UndirectedGraphNode {
4 * int label;
5 * vector<UndirectedGraphNode *> neighbors;
6 * UndirectedGraphNode(int x) : label(x) {};
7 * };
8 */
9 class Solution {
10 public:
11 unordered_map<int, UndirectedGraphNode *> mp;
12 UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
13 if(node == NULL || mp.count(node->label)) return NULL;
14 UndirectedGraphNode *tmp = new UndirectedGraphNode(node->label);
15 mp[node->label] = tmp;
16 for(int i = 0; i < node->neighbors.size(); i ++)
17 {
18 cloneGraph(node->neighbors[i]);
19 tmp->neighbors.push_back(mp[node->neighbors[i]->label]);
20 }
21 return tmp;
22 }
23 };
Palindrome Partitioning II
O(n^2)的动态规划。
cutdp[i] 表示前 i 个字符最小切割几次。
paldp[i][j] == true 表示 i ~ j 是回文。
在枚举 i 和 i 之前的所有 j 的过程中就得到了 paldp[j][i] 的所有回文判断，而对于 i + 1，paldp[j][i + 1]可由 s[j]、s[i + 1]、dp[j + 1][i]在O(1)判断。
cutdp[i]为所有 j (j < i)，当paldp[j + 1][i] == true的 cutdp[j] + 1的最小值。注意一下边界。
1 class Solution {
2 public:
3 int minCut(string s) {
4 bool paldp[s.length()][s.length()];
5 int cutdp[s.length()];
6 for(int i = 0; i < s.length(); i ++)
7 {
8 cutdp[i] = 0x3f3f3f3f;
9 for(int j = i - 1; j >= -1; j --)
10 {
11 if(s.at(j + 1) == s.at(i) && (j + 2 >= i - 1 || paldp[j + 2][i - 1]))
12 {
13 paldp[j + 1][i] = true;
14 cutdp[i] = min(cutdp[i], (j >= 0 ? (cutdp[j] + 1) : 0));
15 }
16 else
17 paldp[j + 1][i] = false;
18
19 }
20 }
21 return cutdp[s.length() - 1];
22 }
23 };
Palindrome Partitioning
O(n^2)动态规划，paldp[i][j] == true表示 i ~ j 是回文。这里DP的方法是基本的，不再多说。
得到paldp之后，DFS一下就可以了。因为单字符是回文，所以DFS的终点肯定都是解，所以不必利用其他的结构存储答案信息。
1 class Solution {
2 public:
3 vector<vector<string> >res;
4 vector<string> tmp;
5 bool **paldp;
6 void DFS(string s, int ith)
7 {
8 if(ith == s.length())
9 {
10 res.push_back(tmp);
11 return;
12 }
13 for(int i = ith; i < s.length(); i ++)
14 {
15 if(paldp[ith][i])
16 {
17 tmp.push_back(s.substr(ith, i - ith + 1));
18 DFS(s, i + 1);
19 tmp.pop_back();
20 }
21 }
22 return;
23 }
24 vector<vector<string> > partition(string s) {
25 paldp = new bool*[s.length()];
26 for(int i = 0; i < s.length(); i ++)
27 paldp[i] = new bool[s.length()];
28 for(int i = 0; i < s.length(); i ++)
29 for(int j = i; j >= 0; j --)
30 paldp[j][i] = s.at(i) == s.at(j) && (j + 1 >= i - 1 || paldp[j + 1][i - 1]);
31 DFS(s, 0);
32 return res;
33 }
34 };
Surrounded Regions
周围四条边的O做起点搜索替换为第三种符号，再遍历所有符号把O换成X，第三种符号换回O。
1 class Solution {
2 public:
3 typedef pair<int, int> pii;
4 int dx[4] = {1, -1, 0, 0};
5 int dy[4] = {0, 0, 1, -1};
6 queue<pii> q;
7 void solve(vector<vector<char> > &board) {
8 if(board.size() == 0) return;
9 int width = board[0].size();
10 int height = board.size();
11 for(int i = 0; i < width; i ++)
12 {
13 if(board[0][i] == 'O')
14 board[0][i] = '#', q.push(pair<int, int>(0, i));
15 if(board[height - 1][i] == 'O')
16 board[height - 1][i] = '#', q.push(pii(height - 1, i));
17 }
18 for(int i = 1; i < height - 1; i ++)
19 {
20 if(board[i][0] == 'O')
21 board[i][0] = '#', q.push(pii(i, 0));
22 if(board[i][width - 1] == 'O')
23 board[i][width - 1] = '#', q.push(pii(i, width - 1));
24 }
25 while(!q.empty())
26 {
27 pii now = q.front();
28 q.pop();
29 for(int i = 0; i < 4; i ++)
30 {
31 int ty = now.first + dx[i];
32 int tx = now.second + dy[i];
33 if(tx >= 0 && tx < width && ty >= 0 && ty < height && board[ty][tx] == 'O')
34 {
35 board[ty][tx] = '#';
36 q.push(pii(ty, tx));
37 }
38 }
39 }
40 for(int i = 0; i < height; i ++)
41 for(int j = 0; j < width; j ++)
42 {
43 if(board[i][j] == 'O') board[i][j] = 'X';
44 else if(board[i][j] == '#') board[i][j] = 'O';
45 }
46 }
47 };
Sum Root to Leaf Numbers
遍历一遍加起来。。。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 int ans;
13 void DFS(TreeNode *now, int tmp)
14 {
15 if(now->left == NULL && now->right == NULL)
16 {
17 ans += tmp * 10 + now->val;
18 return;
19 }
20 if(now->left != NULL)
21 {
22 DFS(now->left, tmp * 10 + now->val);
23 }
24 if(now->right != NULL)
25 {
26 DFS(now->right, tmp * 10 + now->val);
27 }
28 }
29 int sumNumbers(TreeNode *root) {
30 if(root == NULL) return 0;
31 ans = 0;
32 DFS(root, 0);
33 return ans;
34 }
35 };
Longest Consecutive Sequence
方法一：一开始竟然想了并查集，其实绕弯了，多此一举。哈希+并查集，把每个数哈希，枚举每个数看相邻的数在不在数组里，并查集合并，只是并查集的复杂度要比O(1)大一些。
1 class Solution {
2 public:
3 unordered_map<int, int> mp, cnt;
4 int ans = 1;
5 int fa(int i)
6 {
7 i == mp[i] ? i : (mp[i] = fa(mp[i]));
8 }
9 int longestConsecutive(vector<int> &num) {
10 for(int i = 0; i < num.size(); i ++)
11 mp[num[i]] = num[i], cnt[num[i]] = 1;
12 for(int i = 0; i < num.size(); i ++)
13 {
14 if(mp.count(num[i] + 1) && fa(num[i]) != fa(num[i] + 1))
15 {
16 cnt[fa(num[i] + 1)] += cnt[fa(num[i])];
17 ans = max(cnt[fa(num[i] + 1)], ans);
18 mp[fa(num[i])] = fa(num[i] + 1);
19 }
20 }
21 return ans;
22 }
23 };
方法二：哈希+枚举相邻数。相邻的数在数组里的话，每个数之多访问一次；相邻的数不在数组里的话，枚举会中断。所以设哈希复杂度为O(1)的话，这个方法是严格的O(n)。
其实这个题的数据挺善良，如果出了2147483647, -2147483648，那还是用long long 稳妥些。
1 class Solution {
2 public:
3 unordered_map<int, bool> vis;
4 int longestConsecutive(vector<int> &num) {
5 int ans = 0;
6 for(int i = 0; i < num.size(); i ++)
7 vis[num[i]] = false;
8 for(int i = 0; i < num.size(); i ++)
9 {
10 if(vis[num[i]] == false)
11 {
12 int cnt = 0;
13 for(int j = num[i]; vis.count(j); j ++, cnt ++)
14 {
15 vis[j] = true;
16 }
17 for(int j = num[i] - 1; vis.count(j); j --, cnt ++)
18 {
19 vis[j] = true;
20 }
21 ans = max(ans, cnt);
22 }
23 }
24
25 return ans;
26 }
27 };
Word Ladder II
用数组类型的队列，BFS过程中记录pre路径，搜完后迭代回去保存路径。
似乎卡了常数，用queue队列，另外存路径的方法超时了。
想更快就双向广搜吧。让我想起了POJ那个八数码。
1 class Node
2 {
3 public:
4 string str;
5 int pace;
6 int pre;
7 Node(){}
8 Node(string s, int pa, int pr)
9 {
10 str = s;
11 pace = pa;
12 pre = pr;
13 }
14 };
15 class Solution {
16 public:
17 vector<vector<string>> ans;
18 vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
19 vector<Node> q;
20 q.push_back(Node(end, 1, -1));
21 unordered_map<string, int> dis;
22 dis[end] = 1;
23 for(int i = 0; i < q.size(); i ++)
24 {
25 Node now = q[i];
26 if(dis.count(start) && now.pace >= dis[start]) break;
27 for(int j = 0; j < now.str.length(); j ++)
28 {
29 string tmp = now.str;
30 for(char c = 'a'; c <= 'z'; c ++)
31 {
32 tmp[j] = c;
33 if((dict.count(tmp) || tmp == start) && (!dis.count(tmp) || dis[tmp] == now.pace + 1))
34 {
35 dis[tmp] = now.pace + 1;
36 q.push_back(Node(tmp, now.pace + 1, i));
37 }
38 }
39 }
40 }
41 for(int i = q.size() - 1; i >= 0 && q[i].pace == dis[start]; i --)
42 {
43 if(q[i].str == start)
44 {
45 vector<string> tmp;
46 for(int j = i; j != -1; j = q[j].pre)
47 tmp.push_back(q[j].str);
48 ans.push_back(tmp);
49 }
50 }
51 return ans;
52 }
53 };
Word Ladder
直接BFS。
1 class Solution {
2 public:
3 int ladderLength(string start, string end, unordered_set<string> &dict) {
4 typedef pair<string, int> pii;
5 unordered_set<string> flag;
6 queue<pii> q;
7 q.push(pii(start, 1));
8 while(!q.empty())
9 {
10 pii now = q.front();
11 q.pop();
12 for(int i = 0; i < now.first.length(); i ++)
13 {
14 string tmp = now.first;
15 for(char j = 'a'; j <= 'z'; j ++)
16 {
17 tmp[i] = j;
18 if(tmp == end) return now.second + 1;
19 if(dict.count(tmp) && !flag.count(tmp))
20 {
21 q.push(pii(tmp, now.second + 1));
22 flag.insert(tmp);
23 }
24 }
25 }
26 }
27 return 0;
28 }
29 };
做过刘汝佳 白书的人想必都知道ctype.h和isdigit(), isalpha, tolower(), toupper()。
1 class Solution {
2 public:
3 bool valid(char &x)
4 {
5 x = tolower(x);
6 return isdigit(x) || isalpha(x);
7 }
8 bool isPalindrome(string s) {
9 if(s.length() == 0) return true;
10 for(int i = 0, j = s.length() - 1; i < j; i ++, j --)
11 {
12 while(!valid(s[i]) && i < s.length()) i ++;
13 while(!valid(s[j]) && j >= 0) j --;
14 if(i < j && s[i] != s[j]) return false;
15 }
16 return true;
17 }
18 };
Binary Tree Maximum Path Sum
后续遍历，子问题为子树根节点向叶子节点出发的最大路径和。
即 l = DFS(now->left), r = DFS(now->right)。
此时，ans可能是 now->valid,可能是左边一路上来加上now->valid，可能是右边一路上来，也可能是左边上来经过now再右边一路下去，四种情况。
四种情况更新完ans后，now返回上一层只能是 now->valid或左边一路上来或右边一路上来，三种情况。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 int ans;
13 int DFS(TreeNode *now)
14 {
15 if(now == NULL) return 0;
16 int l = max(DFS(now->left), 0);
17 int r = max(DFS(now->right), 0);
18 ans = max(ans, l + r + now->val);
19 return max(l + now->val, r + now->val);
20 }
21 int maxPathSum(TreeNode *root) {
22 if(root == NULL) return 0;
23 ans = -0x3f3f3f3f;
24 DFS(root);
25 return ans;
26 }
27 };
Best Time to Buy and Sell Stock III
前缀pre[i]处理 0 ~ i 买卖一次最优解，后缀suf[i]处理 i ~ prices.size() - 1 买卖一次最优解。
所有位置pre[i] + suf[i]最大值为答案O(n)。
处理最优解的时候是维护前（后）缀prices最小（大）值，与当前prices做差后和前（后）缀最优解比较取最优，O(n)。
总复杂度O(n)。
1 class Solution {
2 public:
3 int maxProfit(vector<int> &prices) {
4 int ans = 0;
5 vector<int> pre(prices.size()), suf(prices.size());
6 for(int i = 0, mtmp = 0x3f3f3f3f; i < prices.size(); i ++)
7 {
8 mtmp = i ? min(mtmp, prices[i]) : prices[i];
9 pre[i] = max(prices[i] - mtmp, i ? pre[i - 1] : 0);
10 }
11 for(int i = prices.size() - 1, mtmp = 0; i >= 0; i --)
12 {
13 mtmp = i != prices.size() - 1 ? max(mtmp, prices[i]) : prices[i];
14 suf[i] = max(mtmp - prices[i], i != prices.size() - 1 ? suf[i + 1] : 0);
15 }
16 for(int i = 0; i < prices.size(); i ++)
17 ans = max(ans, pre[i] + suf[i]);
18 return ans;
19 }
20 };
Best Time to Buy and Sell Stock II
可以买卖多次，把所有上坡差累加即可。
1 class Solution {
2 public:
3 int maxProfit(vector<int> &prices) {
4 int ans = 0;
5 for(int i = 1; i < prices.size(); i ++)
6 {
7 if(prices[i] > prices[i - 1])
8 ans += prices[i] - prices[i - 1];
9 }
10 return ans;
11 }
12 };
Best Time to Buy and Sell Stock
维护前（后）缀最小（大）值，和当前prices做差更新答案。
1 class Solution {
2 public:
3 int maxProfit(vector<int> &prices) {
4 int ans = 0;
5 for(int i = prices.size() - 1, mtmp = 0; i >= 0; i --)
6 {
7 mtmp = max(mtmp, prices[i]);
8 ans = max(mtmp - prices[i], ans);
9 }
10 return ans;
11 }
12 };
Triangle
竟然遇到了ACM递推入门题，想必无数ACMer对这题太熟悉了。
从下往上递推，一维数组滚动更新即可。这里懒省事，直接把原数组改了。
1 class Solution {
2 public:
3 int minimumTotal(vector<vector<int> > &triangle) {
4 for(int i = triangle.size() - 2; i >= 0; i --)
5 {
6 for(int j = 0; j < triangle[i].size(); j ++)
7 triangle[i][j] = min(triangle[i][j] + triangle[i + 1][j], triangle[i][j] + triangle[i + 1][j + 1]);
8 }
9 return triangle.size() == 0 ? 0 : triangle[0][0];
10 }
11 };
Pascal's Triangle II
滚动数组递推，从后往前以便不破坏上一层递推数据。
1 class Solution {
2 public:
3 vector<int> getRow(int rowIndex) {
4 vector<int> ans(rowIndex + 1, 0);
5 ans[0] = 1;
6 for(int i = 0; i <= rowIndex; i ++)
7 {
8 for(int j = i; j >= 0; j --)
9 {
10 ans[j] = (i == 0 || j == 0 || j == i ? 1 : ans[j] + ans[j - 1]);
11 }
12 }
13 return ans;
14 }
15 };
Pascal's Triangle
递推。。
1 class Solution {
2 public:
3 vector<vector<int> > generate(int numRows) {
4 vector<vector<int> > v;
5 for(int i = 0; i < numRows; i ++)
6 {
7 vector<int> tmp;
8 for(int j = 0; j <= i; j ++)
9 {
10 tmp.push_back(i == 0 || j == 0 || j == i ? 1 : v[i - 1][j] + v[i - 1][j - 1]);
11 }
12 v.push_back(tmp);
13 }
14 return v;
15 }
16 };
Populating Next Right Pointers in Each Node II
题目要求空间复杂度O(1)，所以递归、队列等传统方法不应该用。
本题可以利用生成的next指针来横向扫描，即得到一层的next指针之后，可以利用这一层的next指针来给下一层的next指针赋值。
1 /**
2 * Definition for binary tree with next pointer.
3 * struct TreeLinkNode {
4 * int val;
5 * TreeLinkNode *left, *right, *next;
6 * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 TreeLinkNode *findNext(TreeLinkNode *head)
12 {
13 while(head != NULL && head->left == NULL && head->right == NULL)
14 head = head->next;
15 return head;
16 }
17 void connect(TreeLinkNode *root) {
18 if(root == NULL) return;
19 TreeLinkNode *head, *last, *nexhead;
20 for(head = root; head != NULL; head = nexhead)
21 {
22 head = findNext(head);
23 if(head == NULL) break;
24 if(head->left != NULL) nexhead = head->left;
25 else nexhead = head->right;
26 for(last = NULL; head != NULL; last = head, head = findNext(head->next))
27 {
28 if(head->left != NULL && head->right != NULL)
29 head->left->next = head->right;
30 if(last == NULL) continue;
31 if(last->right != NULL)
32 last->right->next = head->left != NULL ? head->left : head->right;
33 else
34 last->left->next = head->left != NULL ? head->left : head->right;
35 }
36 }
37 }
38 };
Populating Next Right Pointers in Each Node
不用考虑连续的空指针，就不用额外实现找下一个子树非空节点，比Populating Next Right Pointers in Each Node II 容易处理。
1 /**
2 * Definition for binary tree with next pointer.
3 * struct TreeLinkNode {
4 * int val;
5 * TreeLinkNode *left, *right, *next;
6 * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 void connect(TreeLinkNode *root) {
12 if(root == NULL) return;
13 TreeLinkNode *head, *nexhead, *last;
14 for(head = root; head->left != NULL; head = nexhead)
15 {
16 nexhead = head->left;
17 last = NULL;
18 while(head != NULL)
19 {
20 head->left->next = head->right;
21 if(last != NULL) last->right->next = head->left;
22 last = head;
23 head = head->next;
24 }
25 }
26 }
27 };
Distinct Subsequences
典型动态规划。dp[i][j] 表示 T 的前 j 个字符在 S 的前 i 个字符中的解。
对于dp[i + 1][j + 1]，由两部分组成：
一、 j + 1 对应到 S 前 i 个字符中的解，忽略 S 的第 i + 1 个字符。
二、判断 S 的第 i + 1 个字符是否和 T 的第 j + 1 个字符相同，如果相同，则加上dp[i][j]，否则不加。
1 class Solution {
2 public:
3 int numDistinct(string S, string T) {
4 if(S.length() < T.length()) return 0;
5 vector<vector<int> > dp(S.length() + 1, vector<int>(T.length() + 1, 0));
6 for(int i = 0; i < S.length(); i ++) dp[i][0] = 1;
7 dp[0][1] = 0;
8 for(int i = 0; i < S.length(); i ++)
9 {
10 for(int j = 0; j < T.length(); j ++)
11 {
12 dp[i + 1][j + 1] = dp[i][j + 1];
13 if(S[i] == T[j]) dp[i + 1][j + 1] += dp[i][j];
14 }
15 }
16 return dp[S.length()][T.length()];
17 }
18 };
Flatten Binary Tree to Linked List
题意是优先左子树靠前，且排成一列用右子树指针，不管val的大小关系。
后序遍历一遍即可，递归返回子树中尾节点指针，注意各种条件判断。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 TreeNode *DFS(TreeNode *now)
13 {
14 if(now->left == NULL && now->right == NULL) return now;
15 TreeNode *leftok = NULL, *rightok = NULL;
16 if(now->left != NULL) leftok = DFS(now->left);
17 if(now->right != NULL) rightok = DFS(now->right);
18 if(leftok != NULL)
19 {
20 leftok->right = now->right;
21 now->right = now->left;
22 now->left = NULL;
23 return rightok ? rightok : leftok;
24 }
25 else return rightok;
26 }
27 void flatten(TreeNode *root) {
28 if(root == NULL) return;
29 DFS(root);
30 }
31 };
传统递归，把路径上的数字插入vector，终点判断是否插入答案。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 int goal;
13 vector<vector<int> >v;
14 vector<int> curv;
15 void DFS(TreeNode *now, int cursum)
16 {
17 curv.push_back(now->val);
18 if(now->left == NULL && now->right == NULL)
19 {
20 if(cursum + now->val == goal)
21 {
22 v.push_back(curv);
23 curv.pop_back();
24 return;
25 }
26 }
27 if(now->left != NULL) DFS(now->left, cursum + now->val);
28 if(now->right != NULL) DFS(now->right, cursum + now->val);
29 curv.pop_back();
30 }
31 vector<vector<int> > pathSum(TreeNode *root, int sum) {
32 goal = sum;
33 if(root == NULL) return v;
34 DFS(root, 0);
35 return v;
36 }
37 };
Path Sum
遍历树。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 int goal;
13 bool DFS(TreeNode *now, int cursum)
14 {
15 if(now->left == NULL && now->right == NULL)
16 return cursum + now->val == goal;
17 if(now->left != NULL && DFS(now->left, cursum + now->val)) return true;
18 if(now->right != NULL && DFS(now->right, cursum + now->val)) return true;
19 }
20 bool hasPathSum(TreeNode *root, int sum) {
21 goal = sum;
22 if(root == NULL) return false;
23 return DFS(root, 0);
24 }
25 };
还是遍历。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 int minDepth(TreeNode *root) {
13 if(root == NULL) return 0;
14 if(root->left == NULL) return minDepth(root->right) + 1;
15 else if(root->right == NULL) return minDepth(root->left) + 1;
16 else return min(minDepth(root->left), minDepth(root->right)) + 1;
17 }
18 };
遍历。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 int maxDepth(TreeNode *now)
13 {
14 if(now == NULL) return 0;
15 int l = maxDepth(now->left) + 1;
16 int r = maxDepth(now->right) + 1;
17 return abs(l - r) > 1 || l < 0 || r < 0 ? -2 : max(l, r);
18 }
19 bool isBalanced(TreeNode *root) {
20 return maxDepth(root) >= 0;
21 }
22 };
Convert Sorted List to Binary Search Tree
每次找中点作为根节点，将两边递归，返回根节点指针作为左右节点。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 /**
10 * Definition for binary tree
11 * struct TreeNode {
12 * int val;
13 * TreeNode *left;
14 * TreeNode *right;
15 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
16 * };
17 */
18 class Solution {
19 public:
20 TreeNode *sortedListToBST(ListNode *head) {
21 if(head == NULL) return NULL;
22 ListNode *p, *mid, *pre;
23 for(p = mid = head, pre = NULL; p->next != NULL; mid = mid->next)
24 {
25 p = p->next;
26 if(p->next == NULL) break;
27 p = p->next;
28 pre = mid;
29 };
30 TreeNode *root = new TreeNode(mid->val);
31 if(pre != NULL) pre->next = NULL, root->left = sortedListToBST(head);
32 else root->left = NULL;
33 root->right = sortedListToBST(mid->next);
34 if(pre != NULL) pre->next = mid;
35 return root;
36 }
37 };
Convert Sorted Array to Binary Search Tree
递归做，比链表的容易些。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 TreeNode *convert(vector<int> &num, int left, int right)
13 {
14 if(right == left) return NULL;
15 int mid = right + left >> 1;
16 TreeNode *root = new TreeNode(num[mid]);
17 root->left = convert(num, left, mid);
18 root->right = convert(num, mid + 1, right);
19 }
20 TreeNode *sortedArrayToBST(vector<int> &num) {
21 return convert(num, 0, num.size());
22 }
23 };
Binary Tree Level Order Traversal II
宽搜和深搜都可以，找对层数就行了。
本以为这题亮点是如何一遍实现从底向上顺序的vector，AC之后上网一查也全是最后把vector翻转的。。。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<vector<int> >v;
13 void DFS(TreeNode *now, int depth)
14 {
15 if(v.size() <= depth) v.push_back(vector<int>(0));
16 v[depth].push_back(now->val);
17 if(now->left != NULL) DFS(now->left, depth + 1);
18 if(now->right != NULL) DFS(now->right, depth + 1);
19 }
20 vector<vector<int> > levelOrderBottom(TreeNode *root) {
21 if(root == NULL) return v;
22 DFS(root, 0);
23 for(int i = 0, j = v.size() - 1; i < j; i ++, j --)
24 swap(v[i], v[j]);
25 return v;
26 }
27 };
Construct Binary Tree from Inorder and Postorder Traversal
数据结构经典题。后序遍历的结尾是根节点 Proot，在中序遍历中找到这个节点 Iroot，则 Iroot两边即为左右子树。根据左右子树节点个数，在后序遍历中找到左右子树分界（左右子树肯定不交叉），则几个关键分界点都找到了，对左右子树递归。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 TreeNode *build(vector<int> &inorder, int ileft, int iright, vector<int> &postorder, int pleft, int pright)
13 {
14 if(iright == ileft)
15 return NULL;
16 int root;
17 for(root = ileft; inorder[root] != postorder[pright - 1]; root ++);
18 TreeNode *node = new TreeNode(inorder[root]);
19 node->left = build(inorder, ileft, root, postorder, pleft, pleft + root - ileft);
20 node->right = build(inorder, root + 1, iright, postorder, pleft + root - ileft, pright - 1);
21 return node;
22 }
23 TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
24 return build(inorder, 0, inorder.size(), postorder, 0, postorder.size());
25 }
26 };
Construct Binary Tree from Preorder and Inorder Traversal
和上一题Construct Binary Tree from Inorder and Postorder Traversal方法一样，前序和后序的信息作用相同。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 TreeNode *build(vector<int> &inorder, int ileft, int iright, vector<int> &preorder, int pleft, int pright)
13 {
14 if(iright == ileft)
15 return NULL;
16 int root;
17 for(root = ileft; inorder[root] != preorder[pleft]; root ++);
18 TreeNode *node = new TreeNode(inorder[root]);
19 node->left = build(inorder, ileft, root, preorder, pleft + 1, pleft + root - ileft);
20 node->right = build(inorder, root + 1, iright, preorder, pleft + root - ileft + 1, pright);
21 return node;
22 }
23 TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
24 return build(inorder, 0, inorder.size(), preorder, 0, preorder.size());
25
26 }
27 };
遍历。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 int maxDepth(TreeNode *root) {
13 if(root == NULL) return 0;
14 if(root->left == NULL) return maxDepth(root->right) + 1;
15 if(root->right == NULL) return maxDepth(root->left) + 1;
16 return max(maxDepth(root->left), maxDepth(root->right)) + 1;
17 }
18 };
Binary Tree Zigzag Level Order Traversal
BFS，奇偶层轮流走，一层左到右，一层右到左。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<vector<int> > ans;
13 vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
14 if(root == NULL) return ans;
15 vector<TreeNode*> q1, q2;
16 q1.push_back(root);
17 int depth = 0;
18 while(!q1.empty() || !q2.empty())
19 {
20 ans.push_back(vector<int>(0));
21 for(int i = q1.size() - 1; i >= 0; i --)
22 {
23 ans[depth].push_back(q1[i]->val);
24 if(q1[i]->left != NULL) q2.push_back(q1[i]->left);
25 if(q1[i]->right != NULL) q2.push_back(q1[i]->right);
26 }
27 depth ++;
28 q1.clear();
29 if(q2.empty()) continue;
30 ans.push_back(vector<int>(0));
31 for(int i = q2.size() - 1; i >= 0; i --)
32 {
33 ans[depth].push_back(q2[i]->val);
34 if(q2[i]->right != NULL) q1.push_back(q2[i]->right);
35 if(q2[i]->left != NULL) q1.push_back(q2[i]->left);
36 }
37 q2.clear();
38 depth ++;
39 }
40 return ans;
41 }
42 };
Binary Tree Level Order Traversal
懒省事直接在上一题Binary Tree Zigzag Level Order Traversal的代码上改了一下。
只用一个队列的话，增加个层数信息存队列里即可。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<vector<int> > ans;
13 vector<vector<int> > levelOrder(TreeNode *root) {
14 if(root == NULL) return ans;
15 vector<TreeNode*> q1, q2;
16 q1.push_back(root);
17 int depth = 0;
18 while(!q1.empty() || !q2.empty())
19 {
20 ans.push_back(vector<int>(0));
21 for(int i = 0; i < q1.size(); i ++)
22 {
23 ans[depth].push_back(q1[i]->val);
24 if(q1[i]->left != NULL) q2.push_back(q1[i]->left);
25 if(q1[i]->right != NULL) q2.push_back(q1[i]->right);
26 }
27 depth ++;
28 q1.clear();
29 if(q2.empty()) continue;
30 ans.push_back(vector<int>(0));
31 for(int i = 0; i < q2.size(); i ++)
32 {
33 ans[depth].push_back(q2[i]->val);
34 if(q2[i]->left != NULL) q1.push_back(q2[i]->left);
35 if(q2[i]->right != NULL) q1.push_back(q2[i]->right);
36 }
37 q2.clear();
38 depth ++;
39 }
40 return ans;
41 }
42 };
Symmetric Tree
递归：左指针和右指针，对称递归，即“左的左”和“右的右”对应，“左的右”和“右的左”对应。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 bool judge(TreeNode *l, TreeNode *r)
13 {
14 if(l->val != r->val) return false;
15 if(l->left != r->right && (l->left == NULL || r->right == NULL)
16 || l->right != r->left && (l->right == NULL || r->left == NULL))
17 return false;
18 if(l->left != NULL && !judge(l->left, r->right)) return false;
19 if(l->right != NULL && !judge(l->right, r->left)) return false;
20 return true;
21 }
22 bool isSymmetric(TreeNode *root) {
23 if(root == NULL) return true;
24 if(root->left == NULL && root->right == NULL) return true;
25 else if(root->left != NULL && root->right == NULL
26 || root->left == NULL && root->right != NULL) return false;
27 return judge(root->left, root->right);
28 }
29 };
非递归：左右子树分别做一个队列，同步遍历。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 bool isSymmetric(TreeNode *root) {
13 if(root == NULL) return true;
14 if(root->left == NULL && root->right == NULL) return true;
15 else if(root->left != NULL && root->right == NULL
16 || root->left == NULL && root->right != NULL) return false;
17 queue<TreeNode *> q1, q2;
18 q1.push(root->left);
19 q2.push(root->right);
20 while(!q1.empty())
21 {
22 TreeNode *now1 = q1.front(), *now2 = q2.front();
23 q1.pop();
24 q2.pop();
25 if(now1->val != now2->val) return false;
26 if(now1->left != NULL || now2->right != NULL)
27 {
28 if(now1->left == NULL || now2->right == NULL) return false;
29 q1.push(now1->left);
30 q2.push(now2->right);
31 }
32 if(now1->right != NULL || now2->left != NULL)
33 {
34 if(now1->right == NULL || now2->left == NULL) return false;
35 q1.push(now1->right);
36 q2.push(now2->left);
37 }
38 }
39 return true;
40 }
41 };
Same Tree
同步遍历，比较判断。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 bool isSameTree(TreeNode *p, TreeNode *q) {
13 if(p == NULL && q == NULL) return true;
14 if(p != q && (p == NULL || q == NULL) || p->val != q->val) return false;
15 return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
16 }
17 };
中序遍历是二叉查找树的顺序遍历，*a, *b表示前驱节点和当前节点，因为只有一对数值翻转了，所以肯定会遇到前驱节点val比当前节点val大的情况一次或两次，遇到一次表示翻转的是相邻的两个节点。*ans1和*ans2指向两个被翻转的节点，当遇到前驱val比当前val大的情况时候，根据第一次还是第二次给ans1和ans2赋值，最终翻转回来。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 TreeNode *a, *b;
13 TreeNode *ans1, *ans2;
14 bool DFS(TreeNode *now)
15 {
16 if(now->left != NULL)
17 DFS(now->left);
18 a = b;
19 b = now;
20 if(a != NULL && a->val > b->val)
21 {
22 if(ans1 == NULL) ans1 = a;
23 ans2 = b;
24 }
25 if(now->right != NULL)
26 DFS(now->right);
27 }
28 void recoverTree(TreeNode *root) {
29 if(root == NULL) return;
30 a = b = ans1 = ans2 = NULL;
31 DFS(root);
32 swap(ans1->val, ans2->val);
33 }
34 };
Validate Binary Search Tree
中序遍历，更新前驱节点，与当前节点比较。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 TreeNode *pre = NULL;
13 bool isValidBST(TreeNode *root) {
14 if(root == NULL) return true;
15 if(root->left != NULL && !isValidBST(root->left)) return false;
16 if(pre != NULL && pre->val >= root->val) return false;
17 pre = root;
18 if(root->right != NULL && !isValidBST(root->right)) return false;
19 return true;
20 }
21 };
Interleaving String
动态规划。如果结果是true，则任意 i, j，s1 i 之前的字符 和 s2 j 之前的字符，都能够交叉为 s3 i + j 之前的字符。
由此，当dp[i][j]时，如果s1[i]==s3[i+j]，则尝试s1[i]与s3[i+j]对应，如果dp[i-1][j]是true，则dp[i][j]也为true。如果s2[j]==s3[i+j]则同样处理。
直到最后，判断dp[s1.length()-1][s2.length()-1]是否为true。为方便初始化，坐标后移了一位。
题目不厚道的出了s1.length()+s2.length() != s3.length()的数据，特判一下。
看到网上也都是O(n^2)的解法，我也就放心了。。。
1 class Solution {
2 public:
3 bool isInterleave(string s1, string s2, string s3) {
4 if(s1.length() + s2.length() != s3.length()) return false;
5 vector<vector<bool> > dp(s1.length() + 1, vector<bool>(s2.length() + 1, false));
6 for(int i = 0; i <= s1.length(); i ++)
7 for(int j = 0; j <= s2.length(); j ++)
8 {
9 if(!i && !j) dp[i][j] = true;
10 dp[i][j] = dp[i][j] || i > 0 && s3[i + j - 1] == s1[i - 1] && dp[i - 1][j];
11 dp[i][j] = dp[i][j] || j > 0 && s3[i + j - 1] == s2[j - 1] && dp[i][j - 1];
12 }
13 return dp[s1.length()][s2.length()];
14 }
15 };
Unique Binary Search Trees II
LeetCode目前为止感觉最暴力的。递归遍历所有情况，每次返回子问题（左右子树）的vector<TreeNode *>的解，两层循环组合这些解。
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<TreeNode *> generate(int start, int end)
13 {
14 vector<TreeNode *>res;
15 if(start > end)
16 {
17 TreeNode *tmp = NULL;
18 res.push_back(tmp);
19 return res;
20 }
21 for(int i = start; i <= end; i ++)
22 {
23 vector<TreeNode *> l = generate(start, i - 1), r = generate(i + 1, end);
24 for(int j = 0; j < l.size(); j ++)
25 for(int k = 0; k < r.size(); k ++)
26 {
27 TreeNode *tmp = new TreeNode(i);
28 tmp->left = l[j];
29 tmp->right = r[k];
30 res.push_back(tmp);
31 }
32 }
33 return res;
34 }
35 vector<TreeNode *> generateTrees(int n) {
36 return generate(1, n);
37 }
38 };
Unique Binary Search Trees
经典问题，卡特兰数，可递推，可用公式（公式用组合数，也要写循环）。
1 class Solution {
2 public:
3 int COM(int n, int m)
4 {
5 m = n - m < m ? n - m : m;
6 int res, i, j;
7 for(i = n, res = j = 1; i > n - m; i --)
8 {
9 res *= i;
10 for(; j <= m && res % j == 0; j ++)
11 res /= j;
12 }
13 return res;
14 }
15 int numTrees(int n) {
16 return COM(n << 1, n) / (n + 1);
17
18 }
19 };
Binary Tree Inorder Traversal
数据结构基础
1 /**
2 * Definition for binary tree
3 * struct TreeNode {
4 * int val;
5 * TreeNode *left;
6 * TreeNode *right;
7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<int> res;
13 void inorder(TreeNode *now)
14 {
15 if(now == NULL) return;
16 inorder(now->left);
17 res.push_back(now->val);
18 inorder(now->right);
19 }
20 vector<int> inorderTraversal(TreeNode *root) {
21 inorder(root);
22 return res;
23 }
24 };
Restore IP Addresses
四层递归枚举分割位置，判断数字范围和前导零，处理字符串。
1 class Solution {
2 public:
3 vector<string> res;
4 void DFS(string s, int last, int cur, string now)
5 {
6 if(cur == 3)
7 {
8 if(last == s.length()) return;
9 string tmp = s.substr(last, s.length() - last);
10 if(atoi(tmp.c_str()) <= 255 && (tmp.length() == 1 || tmp[0] != '0'))
11 res.push_back(now + tmp);
12 return;
13 }
14 string lin;
15 for(int i = last; i < s.length(); i ++)
16 {
17 string tmp = s.substr(last, i - last + 1);
18 if(atoi(tmp.c_str()) <= 255 && (tmp.length() == 1 || tmp[0] != '0'))
19 DFS(s, i + 1, cur + 1, now + tmp + ".");
20 }
21 }
22 vector<string> restoreIpAddresses(string s) {
23 DFS(s, 0, 0, "");
24 return res;
25 }
26 };
Reverse Linked List II
在表头添加一个“哨兵”会好写很多，额外的newhead可以帮助标记翻转之后更换了的头指针。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *reverseBetween(ListNode *head, int m, int n) {
12 ListNode *newhead = new ListNode(0);
13 newhead->next = head;
14 ListNode *pre = newhead, *p = head, *start = NULL;
15 ListNode *tmp;
16 for(int i = 1; p != NULL; i ++)
17 {
18 tmp = p->next;
19 if(i == m)
20 start = pre;
21 if(i > m && i <= n)
22 p->next = pre;
23 if(i == n)
24 {
25 start->next->next = tmp;
26 start->next = p;
27 }
28 pre = p;
29 p = tmp;
30 }
31 tmp = newhead->next;
32 free(newhead);
33 return tmp;
34 }
35 };
Subsets II
统计地存map里，map[i]= j 表示 S 中有 j 个 i。map是有序的，用迭代器递归枚举放入集合的个数。
也可以先排序，用set标记每个数时候被放入过，第一次放入之后才可以继续放同一个数。
代码是用map的方法。
1 class Solution {
2 public:
3 vector<vector<int> > res;
4 vector<int> now;
5 map<int, int> mp;
6 void DFS(map<int, int>::iterator i)
7 {
8 if(i == mp.end())
9 {
10 res.push_back(now);
11 return;
12 }
13 map<int, int>::iterator tmp = i;
14 i ++;
15 DFS(i);
16 for(int j = 0; j < tmp->second; j ++)
17 {
18 now.push_back(tmp->first);
19 DFS(i);
20 }
21 for(int j = 0; j < tmp->second; j ++)
22 now.pop_back();
23 }
24 vector<vector<int> > subsetsWithDup(vector<int> &S) {
25 for(int i = 0; i < S.size(); i ++)
26 !mp.count(S[i]) ? (mp[S[i]] = 1) : mp[S[i]] ++;
27 DFS(mp.begin());
28 return res;
29 }
30 };
Decode Ways
递推：dp[i]表示前 i 个数字的解码种数。
dp[i] = if(一)dp[i-1] + if(二)dp[i-2]
当 i 位置不为0，可加上 i - 1 位置的解。当当前位置和前一位置组成的两位数满足解码且高位不为0，可加上 i - 2 位置的解。
1 class Solution {
2 public:
3 int numDecodings(string s) {
4 if(s.length() == 0) return 0;
5 vector<int> dp(s.length() + 1, 0);
6 dp[0] = 1;
7 for(int i = 0; i < s.length(); i ++)
8 {
9 dp[i + 1] = (s[i] != '0' ? dp[i] : 0) +
10 (i > 0 && s[i - 1] != '0' && atoi(s.substr(i - 1, 2).c_str()) <= 26 ? dp[i - 1] : 0);
11 }
12 return dp[s.length()];
13 }
14 };
Gray Code
格雷码有多种生成方法，可参考维基百科。
1 class Solution {
2 public:
3 vector<int> grayCode(int n) {
4 vector<int> res;
5 for(int i = 0; i < (1 << n); i ++)
6 res.push_back((i >> 1) ^ i);
7 return res;
8 }
9 };
Merge Sorted Array
从后往前，对 A 来说一个萝卜一个坑，肯定不会破坏前面的数据。具体看代码。
1 class Solution {
2 public:
3 void merge(int A[], int m, int B[], int n) {
4 int p = m + n - 1, i = m - 1, j = n - 1;
5 for(; i >= 0 && j >= 0;)
6 {
7 if(A[i] > B[j]) A[p --] = A[i --];
8 else A[p --] = B[j --];
9 }
10 while(i >= 0) A[p --] = A[i --];
11 while(j >= 0) A[p --] = B[j --];
12 }
13 };
Scramble String
直接搜索可以过，记忆化搜索可提高效率。
dp[i][j][k]表示从 s1[i] 和 s2[j] 开始长度为 k 的字符串是否是scrambled string。
枚举分割位置，scrambled string要求字符串对应字母的个数是一致的，可以直接排序对比。递归终点是刚好只有一个字母。
1 class Solution {
2 public:
3 string S1, S2;
4 vector<vector<vector<int> > > dp;
5 bool judge(string a, string b)
6 {
7 sort(a.begin(), a.end());
8 sort(b.begin(), b.end());
9 for(int i = 0; i < a.length(); i ++)
10 if(a[i] != b[i]) return false;
11 return true;
12 }
13 int DFS(int s1start, int s2start, int len)
14 {
15 int &ans = dp[s1start][s2start][len - 1];
16 if(len == 1) return ans = S1[s1start] == S2[s2start];
17 if(ans != -1) return ans;
18 if(!judge(S1.substr(s1start, len), S2.substr(s2start, len))) return ans = 0;
19 ans = 0;
20 for(int i = 1; i < len; i ++)
21 {
22 ans = ans
23 || DFS(s1start, s2start, i) && DFS(s1start + i, s2start + i, len - i)
24 || DFS(s1start, s2start + len - i, i) && DFS(s1start + i, s2start, len - i);
25
26 }
27 return ans;
28 }
29 bool isScramble(string s1, string s2) {
30 S1 = s1, S2 = s2;
31 dp = vector<vector<vector<int> > >
32 (s1.length(), vector<vector<int> >
33 (s1.length(), vector<int>
34 (s1.length(), -1)));
35 return DFS(0, 0, s1.length());
36 }
37 };
Partition List
分存大小最后合并。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *partition(ListNode *head, int x) {
12 ListNode *shead, *bhead, *smaller, *bigger, *p;
13 for(shead = bhead = smaller = bigger = NULL, p = head; p != NULL; p = p->next)
14 {
15 if(p->val < x)
16 {
17 if(shead == NULL)
18 shead = p;
19 if(smaller != NULL)
20 smaller->next = p;
21 smaller = p;
22 }
23 else
24 {
25 if(bhead == NULL)
26 bhead = p;
27 if(bigger != NULL)
28 bigger->next = p;
29 bigger = p;
30 }
31 }
32 if(smaller != NULL) smaller->next = bhead;
33 if(bigger != NULL) bigger->next = NULL;
34 return shead != NULL ? shead : bhead;
35 }
36 };
Maximal Rectangle
方法一：linecnt[i][j]统计第 i 行到第 j 位置有多少个连续的 '1'，接下来枚举列，每一列相当于一次直方图最大矩形统计，计算每个位置向前和向后最远的不少于当前位置值的位置，每次更新结果，总复杂度O(n^2)。
找“最远位置”用迭代指针，理论复杂度略高于O(n)。
1 class Solution {
2 public:
3 int maximalRectangle(vector<vector<char> > &matrix) {
4 if(matrix.size() == 0) return 0;
5 int H = matrix.size(), W = matrix[0].size();
6 int ans = 0;
7 vector<int> left(H), right(H);
8 vector<vector<int> > linecnt(H, vector<int>(W, 0));
9 for(int i = 0; i < H; i ++)
10 {
11 int last = 0;
12 for(int j = 0; j < W; j ++)
13 {
14 if(matrix[i][j] == '1') last ++;
15 else last = 0;
16 linecnt[i][j] = last;
17 }
18 }
19 for(int k = 0; k < W; k ++)
20 {
21 for(int i = 0; i < H; i ++)
22 {
23 if(i == 0) left[i] = -1;
24 else
25 {
26 left[i] = i - 1;
27 while(left[i] > -1 && linecnt[left[i]][k] >= linecnt[i][k])
28 left[i] = left[left[i]];
29 }
30 }
31 for(int i = H - 1; i >= 0; i --)
32 {
33 if(i == H - 1) right[i] = H;
34 else
35 {
36 right[i] = i + 1;
37 while(right[i] < H && linecnt[right[i]][k] >= linecnt[i][k])
38 right[i] = right[right[i]];
39 }
40 ans = max(ans, (right[i] - left[i] - 1) * linecnt[i][k]);
41 }
42 }
43 return ans;
44 }
45 };
用单调栈，理论复杂度O(n)。
1 class Solution {
2 public:
3 int maximalRectangle(vector<vector<char> > &matrix) {
4 if(matrix.size() == 0) return 0;
5 vector<vector<int> > linecnt(matrix.size(), vector<int>(matrix[0].size(), 0));
6 for(int i = 0; i < matrix.size(); i ++)
7 {
8 int last = 0;
9 for(int j = 0; j < matrix[0].size(); j ++)
10 {
11 if(matrix[i][j] == '1') last ++;
12 else last = 0;
13 linecnt[i][j] = last;
14 }
15 }
16 int ans = 0;
17 for(int k = 0; k < matrix[0].size(); k ++)
18 {
19 stack<int> s, site;
20 vector<int>last(matrix.size());
21 for(int i = 0; i < matrix.size(); i ++)
22 {
23 while(!s.empty() && s.top() >= linecnt[i][k])
24 s.pop(), site.pop();
25 if(!s.empty()) last[i] = site.top() + 1;
26 else last[i] = 0;
27 s.push(linecnt[i][k]);
28 site.push(i);
29 }
30 while(!s.empty()) s.pop(), site.pop();
31 for(int i = matrix.size() - 1; i >= 0; i --)
32 {
33 while(!s.empty() && s.top() >= linecnt[i][k])
34 s.pop(), site.pop();
35 if(!s.empty()) ans = max(ans, (site.top() - last[i]) * linecnt[i][k]);
36 else ans = max(ans, (int)(matrix.size() - last[i]) * linecnt[i][k]);
37 s.push(linecnt[i][k]);
38 site.push(i);
39 }
40 }
41 return ans;
42 }
43 };
方法二：每个 '1' 的点当作一个矩形的底部，left[j]、right[j]、height[j]表示当前行第 j 个位置这个点向左、右、上伸展的最大矩形的边界，作为滚动数组，下一行的数据可以由上一行结果得到，总复杂度O(n^2)。
left[j] = max(这一行最左, left[j]（上一行最左） );
right[j] = min(这一行最右，right[j]（上一行最右） );
height[j] = height[j - 1] + 1;
1 class Solution {
2 public:
3 int maximalRectangle(vector<vector<char> > &matrix) {
4 if(matrix.size() == 0) return 0;
5 int H = matrix.size(), W = matrix[0].size();
6 vector<int> left(W, -1), right(W, W), height(W, 0);
7 int ans = 0;
8 for(int i = 0; i < H; i ++)
9 {
10 int last = -1;
11 for(int j = 0; j < W; j ++)
12 {
13 if(matrix[i][j] == '1')
14 {
15 if(last == -1) last = j;
16 left[j] = max(left[j], last);
17 height[j] ++;
18 }
19 else
20 {
21 last = -1;
22 left[j] = -1;
23 height[j] = 0;
24 }
25 }
26 last = -1;
27 for(int j = W - 1; j >= 0; j --)
28 {
29 if(matrix[i][j] == '1')
30 {
31 if(last == -1) last = j;
32 right[j] = min(right[j], last);
33 ans = max(ans, height[j] * (right[j] - left[j] + 1));
34 }
35 else
36 {
37 last = -1;
38 right[j] = W;
39 }
40 }
41 }
42 return ans;
43 }
44 };
Largest Rectangle in Histogram
参考上一题Maximal Rectangle方法一。
1 class Solution {
2 public:
3 int largestRectangleArea(vector<int> &height) {
4 if(height.size() == 0) return 0;
5 vector<int> left(height.size()), right(height.size());
6 int ans = 0;
7 for(int i = 0; i < height.size(); i ++)
8 {
9 if(i == 0) left[i] = -1;
10 else
11 {
12 left[i] = i - 1;
13 while(left[i] > -1 && height[i] <= height[left[i]])
14 left[i] = left[left[i]];
15 }
16 }
17 for(int i = height.size() - 1; i >= 0; i --)
18 {
19 if(i == height.size() - 1) right[i] = height.size();
20 else
21 {
22 right[i] = i + 1;
23 while(right[i] < height.size() && height[i] <= height[right[i]])
24 right[i] = right[right[i]];
25 }
26 ans = max(ans, (right[i] - left[i] - 1) * height[i]);
27 }
28 return ans;
29 }
30 };
Remove Duplicates from Sorted List II
加个表头乱搞吧。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *deleteDuplicates(ListNode *head) {
12 if(head == NULL || head->next == NULL) return head;
13 ListNode *newhead = new ListNode(0);
14 newhead->next = head;
15 for(ListNode *pre = newhead, *now = head, *nex = head->next; nex != NULL;)
16 {
17 if(now->val == nex->val)
18 {
19 while(nex != NULL && now->val == nex->val)
20 {
21 free(now);
22 now = nex;
23 nex = nex->next;
24 }
25 free(now);
26 pre->next = nex;
27 if(nex == NULL) break;
28 }
29 else pre = now;
30 now = nex;
31 nex = nex->next;
32 }
33 head = newhead->next;
34 free(newhead);
35 return head;
36 }
37 };
Remove Duplicates from Sorted List
直接操作。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *deleteDuplicates(ListNode *head) {
12 if(head == NULL || head->next == NULL) return head;
13 for(ListNode *pre = head, *p = head->next; p != NULL;)
14 {
15 while(p != NULL && pre->val == p->val)
16 {
17 pre->next = p->next;
18 free(p);
19 p = pre->next;
20 }
21 if(p == NULL) break;
22 pre = p;
23 p = p->next;
24 }
25 return head;
26 }
27 };
Search in Rotated Sorted Array II
以mid为界，左右两边至少有一边是有序的。由于不可避免地会有O(n)的可能性，所以确定的时候二分，不确定的时候单位缩减边界。
1 class Solution {
2 public:
3 bool search(int A[], int n, int target) {
4 int left = 0, right = n - 1, mid;
5 while(left < right)
6 {
7 mid = left + right >> 1;
8 if(target < A[mid] && A[left] < target) right = mid;
9 else if(target < A[right] && A[mid] < target) left = mid + 1;
10 else
11 {
12 if(A[left] == target || A[right] == target) return true;
13 else if(A[left] < target) left ++;
14 else if(target < A[right]) right --;
15 else return false;
16 }
17 }
18 return A[left] == target ? true : false;
19 }
20 };
Remove Duplicates from Sorted Array II
记下放了几个，多了不放。
1 class Solution {
2 public:
3 int removeDuplicates(int A[], int n) {
4 int i, j, cnt;
5 for(i = j = cnt = 0; i < n; i ++)
6 {
7 if(j != 0 && A[j - 1] == A[i]) cnt ++;
8 else cnt = 0;
9 if(cnt < 2) A[j ++] = A[i];
10 }
11 return j;
12 }
13 };
基础DFS。
1 class Solution {
2 public:
3 int dx[4] = {1, -1, 0, 0};
4 int dy[4] = {0, 0, 1, -1};
5 bool DFS(int x, int y, vector<vector<char> > &board, string word, int ith)
6 {
7 if(board[x][y] != word[ith]) return false;
8 if(ith == word.length() - 1) return true;
9 board[x][y] = '.';
10 for(int i = 0; i < 4; i ++)
11 {
12 int nx = x + dx[i];
13 int ny = y + dy[i];
14 if(nx >= 0 && ny >= 0 && nx < board.size() && ny < board[0].size())
15 {
16 if(DFS(nx, ny, board, word, ith + 1))
17 {
18 board[x][y] = word[ith];
19 return true;
20 }
21 }
22 }
23 board[x][y] = word[ith];
24 return false;
25 }
26 bool exist(vector<vector<char> > &board, string word) {
27 for(int i = 0; i < board.size(); i ++)
28 {
29 for(int j = 0; j < board[0].size(); j ++)
30 {
31 if(DFS(i, j, board, word, 0)) return true;
32 }
33 }
34 return false;
35 }
36 };
Subsets
基础DFS。
1 class Solution {
2 public:
3 vector<int> now;
4 vector<vector<int> > res;
5 void DFS(vector<int> &S, int ith)
6 {
7 if(ith == S.size())
8 {
9 res.push_back(now);
10 return;
11 }
12 DFS(S, ith + 1);
13 now.push_back(S[ith]);
14 DFS(S, ith + 1);
15 now.pop_back();
16 }
17 vector<vector<int> > subsets(vector<int> &S) {
18 sort(S.begin(), S.end());
19 DFS(S, 0);
20 return res;
21 }
22 };
Combinations
基础DFS。
1 class Solution {
2 public:
3 vector<int> now;
4 vector<vector<int> > res;
5 void DFS(int n, int ith, int sum, int k)
6 {
7 if(sum == k)
8 {
9 res.push_back(now);
10 return;
11 }
12 if(sum + n - ith + 1 > k)
13 {
14 DFS(n, ith + 1, sum, k);
15 }
16 now.push_back(ith);
17 DFS(n, ith + 1, sum + 1, k);
18 now.pop_back();
19 }
20 vector<vector<int> > combine(int n, int k) {
21 DFS(n, 1, 0, k);
22 return res;
23 }
24 };
Minimum Window Substring
先统计 T 中各字符都有多少个，然后两个下标一前(i)一后(j)在 S 上跑， 当 i 跑到把 T 中字符都包含的位置时候，让 j 追到第一个包含 T 的字符的地方，更新结果，去掉 j 这个位置字符的统计，让 i 继续跑，如此反复。
i 和 j 都只遍历一遍 S，复杂度 O(n)。
1 class Solution {
2 public:
3 string minWindow(string S, string T) {
4 vector<int> cnt(256, 0), need(256, 0);
5 int sum = 0, len = 0x3f3f3f3f;
6 string ans;
7 for(int i = 0; i < T.size(); i ++)
8 need[T[i]] ++;
9 for(int i = 0, j = 0; i < S.length(); j ++)
10 {
11 while(i < S.length() && sum < T.length())
12 {
13 if(cnt[S[i]] < need[S[i]])
14 sum ++;
15 cnt[S[i]] ++;
16 i ++;
17 }
18 while(sum == T.length() && j < S.length())
19 {
20 cnt[S[j]] --;
21 if(cnt[S[j]] < need[S[j]])
22 break;
23 j ++;
24 }
25 if(sum < T.length()) break;
26 if(i - j < len)
27 ans = S.substr(j, i - j), len = i - j;
28 sum --;
29 }
30 return ans;
31 }
32 };
轮流找：
1 class Solution {
2 public:
3 void sortColors(int A[], int n) {
4 int find = 0;
5 for(int i = 0, j = n - 1; i < n; i ++)
6 {
7 if(A[i] == find) continue;
8 while(j > i && A[j] != find) j --;
9 if(j > i) swap(A[i], A[j]);
10 else i --, j = n - 1, find ++;
11 }
12 }
13 };
找到哪个放哪个：
1 class Solution {
2 public:
3 void sortColors(int A[], int n) {
4 int p0, p1, p2;
5 for(p0 = 0, p1 = p2 = n - 1; p0 < p1; )
6 {
7 if(A[p0] == 0) p0 ++;
8 if(A[p0] == 1) swap(A[p0], A[p1 --]);
9 if(A[p0] == 2)
10 {
11 swap(A[p0], A[p2 --]);
12 p1 = p2;
13 }
14 }
15 }
16 };
Search a 2D Matrix
写两个二分查找。或者把整个矩阵看作一维，直接二分，换算坐标。
1 class Solution {
2 public:
3 bool searchMatrix(vector<vector<int> > &matrix, int target) {
4 int left, right, mid;
5 for(left = 0, right = matrix.size(); left < right - 1; )
6 {
7 mid = left + right >> 1;
8 if(matrix[mid][0] > target) right = mid;
9 else left = mid;
10 }
11 if(left == matrix.size() || right == 0) return false;
12 vector<int> &a = matrix[left];
13 for(left = 0, right = a.size(); left < right - 1;)
14 {
15 mid = left + right >> 1;
16 if(a[mid] > target) right = mid;
17 else left = mid;
18 }
19 if(left == a.size() || right == 0) return false;
20 return a[left] == target;
21 }
22 };
Set Matrix Zeroes
O(m+n)的方法是容易想到的，而空间复杂度O(1)，只要利用原矩阵的一行和一列来使用O(m+n)的方法就行了。
1 class Solution {
2 public:
3 void setZeroes(vector<vector<int> > &matrix) {
4 if(matrix.size() == 0) return;
5 int x = -1, y = -1;
6 for(int i = 0; i < matrix.size(); i ++)
7 {
8 for(int j = 0; j < matrix[0].size(); j ++)
9 {
10 if(matrix[i][j] == 0)
11 {
12 if(x == -1)
13 {
14 x = i, y = j;
15 }
16 else
17 {
18 matrix[x][j] = 0;
19 matrix[i][y] = 0;
20 }
21 }
22 }
23 }
24 if(x == -1) return;
25 for(int i = 0; i < matrix.size(); i ++)
26 for(int j = 0; j < matrix[0].size(); j ++)
27 if((matrix[x][j] == 0 || matrix[i][y] == 0) && (i != x && j != y)) matrix[i][j] = 0;
28 for(int i = 0; i < matrix.size(); i ++) matrix[i][y] = 0;
29 for(int j = 0; j < matrix[0].size(); j ++) matrix[x][j] = 0;
30 }
31 };
Edit Distance
动态规划，先初始化 dp[i][0] 和 dp[0][i]，即每个字符串对应空串的编辑距离为串长度，之后对每个位置取子问题加上当前位置 改、删、增得解的最小值。
1 class Solution {
2 public:
3 int minDistance(string word1, string word2) {
4 vector<vector<int> > dp(word1.length() + 1, vector<int>(word2.length() + 1, 0));
5 for(int i = 0; i < word1.length(); i ++) dp[i + 1][0] = i + 1;
6 for(int i = 0; i < word2.length(); i ++) dp[0][i + 1] = i + 1;
7 for(int i = 0; i < word1.length(); i ++)
8 for(int j = 0; j < word2.length(); j ++)
9 {
10 if(word1[i] != word2[j])
11 dp[i + 1][j + 1] = min(dp[i][j] + 1, min(dp[i][j + 1] + 1, dp[i + 1][j] + 1));
12 else
13 dp[i + 1][j + 1] = min(dp[i][j], min(dp[i][j + 1] + 1, dp[i + 1][j] + 1));
14 }
15 return dp[word1.length()][word2.length()];
16 }
17 };
Simplify Path
好烦人的题，没什么好说的。
1 class Solution {
2 public:
3 string simplifyPath(string path) {
4 stack<string> s;
5 string str;
6 for(int i = 0; i < path.length(); i ++)
7 {
8 if(path[i] == '/')
9 {
10 if(str == "..")
11 {
12 if(!s.empty())
13 s.pop();
14 }
15 else if(str != "." && str != "")
16 s.push(str);
17 str.clear();
18 }
19 else
20 str += path[i];
21 }
22 if(str == "..")
23 {
24 if(!s.empty())
25 s.pop();
26 }
27 else if(str != "." && str != "")
28 s.push(str);
29 if(s.empty()) return "/";
30 for(str.clear(); !s.empty(); s.pop())
31 str = "/" + s.top() + str;
32 return str;
33 }
34 };
Climbing Stairs
递推，就是斐波那契数列。
1 class Solution {
2 public:
3 int climbStairs(int n) {
4 return (int)
5 (pow((1+sqrt(5))/2, n + 1) / sqrt(5) -
6 pow((1-sqrt(5))/2, n + 1) / sqrt(5) + 0.1);
7 }
8 };
Sqrt(x)
牛顿迭代。
设输入为n，f(x)=x^2-n，解就是f(x)=0时的x。
设猜了一数x[0]，那么在f(x)在x[0]处的切线与x轴的交点x[1]更接近目标解（可画图看看）。
那么递推下去，x[i]=(x[i-1]+n/x[i-1])/2，用double，越推越精确，直到自己想要的精度。
1 class Solution {
2 public:
3 int sqrt(int x) {
4 double now, last;
5 if(x == 0) return 0;
6 for(now = last = (double)x; ; last = now)
7 {
8 now = (last + (x / last)) * 0.5;
9 if(fabs(last - now) < 1e-5) break;
10 }
11 return (int)(now + 1e-6);
12 }
13 };
Text Justification
每行限制长度，空格均匀插入，不能完全平均的情况下优先靠前的单词间隔。
最后一行特别处理，单词间只有一个空格，剩下的放在末尾。
1 class Solution {
2 public:
3 vector<string> fullJustify(vector<string> &words, int L) {
4 vector<string> ans;
5 int cnt = 0, i, j, k, l;
6 for(i = 0, j = 0; j < words.size(); i ++)
7 {
8 if(i < words.size())
9 {
10 cnt += words[i].length();
11 if(i == j) continue;
12 }
13 if(i == words.size() || (L - cnt) / (i - j) < 1)
14 {
15 int blank = 0;
16 if(i < words.size()) blank = (i - j - 1) ? (L - cnt + words[i].length()) / (i - j - 1) : 0;
17 string tmp = "";
18 l = i < words.size() ? (L - cnt + words[i].length() - blank * (i - j - 1)) : 0;
19 for(k = j; k < i; k ++, l --)
20 {
21 tmp += words[k];
22 if(k != i - 1)
23 {
24 if(i != words.size())
25 {
26 for(int bl = 0; bl < blank; bl ++) tmp += " ";
27 if(l > 0) tmp += " ";
28 }
29 else
30 tmp += " ";
31 }
32 }
33 while(tmp.length() < L) tmp += " ";
34 ans.push_back(tmp);
35 cnt = 0;
36 j = i;
37 i --;
38 }
39 }
40 return ans;
41 }
42 };
Plus One
大整数加法。
1 class Solution {
2 public:
3 vector<int> plusOne(vector<int> &digits) {
4 int cur, i;
5 if(digits.size() == 0) return digits;
6 for(i = digits.size() - 1, cur = 1; i >= 0; i --)
7 {
8 int tmp = digits[i] + cur;
9 cur = tmp / 10;
10 digits[i] = tmp % 10;
11 }
12 if(cur) digits.insert(digits.begin(), cur);
13 return digits;
14 }
15 };
Valid Number
用DFA也不麻烦，题目定义太模糊，为了理解规则错很多次也没办法。
1 class Solution {
2 public:
3
4 int f[11][129];
5 const int fail = -1; //非法
6 const int st = 0; //起始
7 const int pn = 1; //正负号
8 const int di = 2; //整数部分
9 const int del = 3; //前面无数字小数点
10 const int ddi = 4; //小数部分
11 const int ndel = 5; //前面有数字小数点
12 const int dibl = 6; //数后空格
13 const int ex = 7; //进入指数
14 const int epn = 8; //指数符号
15 const int edi = 9; //指数数字
16 const int end = 10; //正确结束
17 void buildDFA()
18 {
19 memset(f, -1, sizeof(f));
20 f[st][' '] = st;
21 f[st]['+'] = f[st]['-'] = pn;
22 for(int i = '0'; i <= '9'; i ++)
23 {
24 f[st][i] = f[pn][i] = f[di][i] = di;
25 f[del][i] = f[ndel][i] = f[ddi][i] = ddi;
26 f[ex][i] = f[epn][i] = f[edi][i] = edi;
27 }
28 f[di]['.'] = ndel;
29 f[st]['.'] = f[pn]['.'] = del;
30 f[di][' '] = f[ndel][' '] = f[ddi][' '] = f[dibl][' '] = f[edi][' '] = dibl;
31 f[di][0] = f[ndel][0] = f[dibl][0] = f[ddi][0] = f[edi][0] = end;
32 f[di]['e'] = f[ndel]['e'] = f[ddi]['e'] = ex;
33 f[ex][' '] = ex;
34 f[ex]['+'] = f[ex]['-'] = epn;
35 }
36 bool DFA(const char *s)
37 {
38 int situ = st;
39 for(int i = 0;; i ++)
40 {
41 situ = f[situ][s[i]];
42 if(situ == end) return true;
43 if(situ == fail) return false;
44 }
45 return true;
46 }
47 bool isNumber(const char *s) {
48 buildDFA();
49 return DFA(s);
50 }
51 };
翻转，大整数加法，再翻转。无心情优化。
1 class Solution {
2 public:
3 string addBinary(string a, string b) {
4 reverse(a.begin(), a.end());
5 reverse(b.begin(), b.end());
6 string c;
7 int cur = 0, i;
8 for(i = 0; i < min(a.length(), b.length()); i ++)
9 {
10 int tmp = a[i] - '0' + b[i] - '0' + cur;
11 cur = tmp >> 1;
12 c += (tmp & 1) + '0';
13 }
14 string &t = a.length() > b.length() ? a : b;
15 for(; i < t.length(); i ++)
16 {
17 int tmp = t[i] - '0' + cur;
18 cur = tmp >> 1;
19 c += (tmp & 1) + '0';
20 }
21 if(cur) c += '1';
22 reverse(c.begin(), c.end());
23 return c;
24 }
25 };
归并排序的一次操作，设个哨兵头结点，结束后free。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
12 ListNode *thead = new ListNode(0), *p = thead;
13 while(l1 != NULL && l2 != NULL)
14 {
15 if(l1->val < l2->val) p->next = l1, p = l1, l1 = l1->next;
16 else p->next = l2, p = l2, l2 = l2->next;
17 }
18 while(l1 != NULL) p->next = l1, p = l1, l1 = l1->next;
19 while(l2 != NULL) p->next = l2, p = l2, l2 = l2->next;
20 p = thead->next;
21 free(thead);
22 return p;
23 }
24 };
递推
1 class Solution {
2 public:
3 int minPathSum(vector<vector<int> > &grid) {
4 if(grid.size() == 0) return 0;
5 for(int i = 0; i < grid.size(); i ++)
6 {
7 for(int j = 0; j < grid[0].size(); j ++)
8 {
9 int tmp = 0x3f3f3f3f;
10 if(i > 0) tmp = min(tmp, grid[i][j] + grid[i - 1][j]);
11 if(j > 0) tmp = min(tmp, grid[i][j] + grid[i][j - 1]);
12 grid[i][j] = tmp == 0x3f3f3f3f ? grid[i][j] : tmp;
13 }
14 }
15 return grid[grid.size() - 1][grid[0].size() - 1];
16 }
17 };
Unique Paths II
递推
1 class Solution {
2 public:
3 int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
4 if(obstacleGrid.size() == 0) return 0;
5 obstacleGrid[0][0] = obstacleGrid[0][0] != 1;
6 for(int i = 0; i < obstacleGrid.size(); i ++)
7 for(int j = 0; j < obstacleGrid[0].size(); j ++)
8 {
9 if(i == 0 && j == 0) continue;
10 if(obstacleGrid[i][j] == 1)
11 {
12 obstacleGrid[i][j] = 0;
13 continue;
14 }
15 if(i > 0) obstacleGrid[i][j] += obstacleGrid[i - 1][j];
16 if(j > 0) obstacleGrid[i][j] += obstacleGrid[i][j - 1];
17 }
18 return obstacleGrid[obstacleGrid.size() - 1][obstacleGrid[0].size() - 1];
19 }
20 };
这是当年学组合数时候的经典题型吧。
1 class Solution {
2 public:
3 int COM(int a, int b)
4 {
5 b = min(b, a - b);
6 int ret = 1, i, j;
7 for(i = a, j = 1; i > a - b; i --)
8 {
9 ret *= i;
10 for(; j <= b && ret % j == 0; j ++)
11 ret /= j;
12 }
13 return ret;
14 }
15 int uniquePaths(int m, int n) {
16 return COM(m + n - 2, m - 1);
17 }
18 };
Rotate List
因为k可能比长度大，需要求长度然后k对长度取模。那么就不要矫情地追求双指针一遍扫描了。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *rotateRight(ListNode *head, int k) {
12 if(head == NULL) return NULL;
13 int cnt;
14 ListNode *en, *p;
15 for(cnt = 1, en = head; en->next != NULL; cnt ++, en = en->next);
16 k %= cnt;
17 for(p = head, cnt --; cnt != k; cnt --, p = p->next);
18 en->next = head;
19 en = p->next;
20 p->next = NULL;
21 return en;
22 }
23 };
Permutation Sequence
一位一位算，每一位优先没使用过的较小的数字，而其后剩下的m个位置有 m! 种排列方法，用 k 减去，直到k不大于这个方法数，则这一位就是枚举到的这个数。
1 class Solution {
2 public:
3 int permu[10];
4 bool vis[10];
5 string getPermutation(int n, int k) {
6 permu[0] = 1;
7 for(int i = 1; i < 10; i ++) permu[i] = permu[i - 1] * i;
8 memset(vis, 0, sizeof(vis));
9 string ans;
10 for(int i = 1; i <= n; i ++)
11 {
12 for(int j = 1; j <= n; j ++)
13 {
14 if(!vis[j])
15 {
16 if(k > permu[n - i]) k -= permu[n - i];
17 else {ans += '0' + j; vis[j] = true; break;}
18 }
19 }
20 }
21 return ans;
22 }
23 };
Spiral Matrix II
直接算每个位置的数是多少有木有很霸气
先看当前位置之外有几个嵌套的正方形，再看当前位置在当前正方形四条边的第几条，求出坐标(x,y)位置的数。
1 class Solution {
2 public:
3 vector<vector<int> > res;
4 vector<int> nsq;
5 int calnum(int i, int j, int n)
6 {
7 int num, tmp;
8 tmp = min(min(i, j), min(n - 1 - i, n - 1 - j));
9 num = nsq[tmp];
10 if(i == tmp) return num + j - tmp + 1;
11 if(n - j - 1 == tmp) return num + n - 2 * tmp + i - tmp;
12 if(n - i - 1 == tmp) return num + 2 * (n - 2 * tmp) - 2 + n - j - tmp;
13 return num + 3 * (n - 2 * tmp) - 3 + n - i - tmp;
14 }
15 vector<vector<int> > generateMatrix(int n) {
16 nsq.push_back(0);
17 for(int i = n; i > 0; i -= 2) nsq.push_back(4 * i - 4);
18 for(int i = 1; i < nsq.size(); i ++) nsq[i] += nsq[i - 1];
19 for(int i = 0; i < n; i ++)
20 {
21 vector<int> tmp;
22 for(int j = 0; j < n; j ++)
23 {
24 tmp.push_back(calnum(i, j, n));
25 }
26 res.push_back(tmp);
27 }
28 return res;
29 }
30 };
从后往前找。
1 class Solution {
2 public:
3 int lengthOfLastWord(const char *s) {
4 int i, j;
5 for(i = strlen(s) - 1; i >= 0 && s[i] == ' '; i --);
6 for(j = i - 1; j >= 0 && s[j] != ' '; j --);
7 return i < 0 ? 0 : i - j;
8 }
9 };
Insert Interval
end 比 newInterval 的 start 小的 intervals 直接插入，从 end 比 newInterval 的 start 大的 intervals 开始，到 start 比 newInterval 的 end 大的 intervals 结束，对这部分区间合并，再把之后的 intervals直接插入，特判 newInterval 最小和最大两种极端情况。
1 /**
2 * Definition for an interval.
3 * struct Interval {
4 * int start;
5 * int end;
6 * Interval() : start(0), end(0) {}
7 * Interval(int s, int e) : start(s), end(e) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<Interval> res;
13 vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
14 if(intervals.size() == 0) {res.push_back(newInterval); return res;}
15 int i, j;
16 for(i = 0; i < intervals.size() && newInterval.start > intervals[i].end; i ++)
17 res.push_back(intervals[i]);
18 for(j = i; j < intervals.size() && newInterval.end >= intervals[j].start; j ++);
19 if(j != 0 && i != intervals.size())
20 res.push_back(Interval(min(intervals[i].start, newInterval.start),
21 max(intervals[j - 1].end, newInterval.end)));
22 else
23 res.push_back(newInterval);
24 for(; j < intervals.size(); j ++) res.push_back(intervals[j]);
25 return res;
26 }
27 };
先按start排个序，然后慢慢合并。。。
1 /**
2 * Definition for an interval.
3 * struct Interval {
4 * int start;
5 * int end;
6 * Interval() : start(0), end(0) {}
7 * Interval(int s, int e) : start(s), end(e) {}
8 * };
9 */
10 class Solution {
11 public:
12 vector<Interval> res;
13 static bool cxompp(const Interval &a, const Interval &b)
14 {return a.start < b.start;}
15 vector<Interval> merge(vector<Interval> &intervals) {
16 if(intervals.size() == 0) return res;
17 sort(intervals.begin(), intervals.end(), cxompp);
18 Interval last = intervals[0];
19 for(int i = 1; i < intervals.size(); i ++)
20 {
21 if(last.end >= intervals[i].start)
22 last.end = max(last.end, intervals[i].end);
23 else
24 res.push_back(last), last = intervals[i];
25 }
26 res.push_back(last);
27 return res;
28 }
29 };
Jump Game
维护最大可跳距离，每个位置都枚举一次。
1 class Solution {
2 public:
3 bool canJump(int A[], int n) {
4 if(n == 0) return false;
5 int i, jumpdis;
6 for(i = jumpdis = 0; i < n && jumpdis >= 0; i ++, jumpdis --)
7 jumpdis = max(A[i], jumpdis);
8 return i == n;
9 }
10 };
Spiral Matrix
模拟转一遍吧。写了俩代码，差不多，处理拐弯的方式略有不同。
代码一：
1 class Solution {
2 public:
3 int dx[4] = {0, 1, 0, -1};
4 int dy[4] = {1, 0, -1, 0};
5 vector<int> res;
6 bool JudgeValid(int x, int y,
7 vector<vector<bool> > &vis, vector<vector<int> > &matrix)
8 {
9 return x >= 0 && x < matrix.size() &&
10 y >= 0 && y < matrix[0].size() && vis[x][y] == false;
11 }
12 vector<int> spiralOrder(vector<vector<int> > &matrix) {
13 int dir, x, y, nx, ny;
14 if(matrix.size() == 0) return res;
15 vector<vector<bool> > vis(matrix.size(), vector<bool>(matrix[0].size(), false));
16 for(dir = x = y = 0; JudgeValid(x, y, vis, matrix); x = nx, y = ny)
17 {
18 res.push_back(matrix[x][y]);
19 vis[x][y] = true;
20 nx = x + dx[dir];
21 ny = y + dy[dir];
22 if(!JudgeValid(nx, ny, vis, matrix))
23 {
24 dir = (dir + 1) % 4;
25 nx = x + dx[dir];
26 ny = y + dy[dir];
27 }
28 }
29 return res;
30 }
31 };
代码二：
1 class Solution {
2 public:
3 int dx[4] = {0, 1, 0, -1};
4 int dy[4] = {1, 0, -1, 0};
5 vector<int> res;
6 vector<int> spiralOrder(vector<vector<int> > &matrix) {
7 int dir, x, y, nx, ny;
8 int l, r, u, d;
9 if(matrix.size() == 0) return res;
10 l = u = -1;
11 r = matrix[0].size();
12 d = matrix.size();
13 for(dir = x = y = 0; res.size() < matrix.size() * matrix[0].size();
14 x = nx, y = ny)
15 {
16 res.push_back(matrix[x][y]);
17 nx = x + dx[dir];
18 ny = y + dy[dir];
19 if(nx == d || nx == u || ny == r || ny == l)
20 {
21 dir = (dir + 1) % 4;
22 if(dir == 0) l ++, r --, d --;
23 else if(dir == 3) u ++;
24 nx = x + dx[dir];
25 ny = y + dy[dir];
26 }
27 }
28 return res;
29 }
30 };
Maximum Subarray
最大子串和，子串要求至少包含一个数字。
一个变量 sum 表示当前求得的子串和，当 sum 小于0时，对后面的子串没有贡献，则把 sum 置零，中间处理一下要求至少包含一个数字的要求即可。
1 class Solution {
2 public:
3 int maxSubArray(int A[], int n) {
4 int ans = A[0], sum = 0;
5 for(int i = 0; i < n; i ++)
6 {
7 sum += A[i];
8 if(sum < 0) sum = 0, ans = max(ans, A[i]);
9 else ans = max(ans, sum);
10 }
11 return ans;
12 }
13 };
N-Queens II
题目没说 n 的取值范围，就不用 位运算 做标记了。
老老实实开三个 bool 数组，一个标记纵列，另外两个标记两个斜列，一行一行DFS。
1 class Solution {
2 public:
3 vector<bool> col, lc, rc;
4 int ans;
5 void DFS(int cur, int n)
6 {
7 if(cur == n)
8 {
9 ans ++;
10 return;
11 }
12 for(int i = 0; i < n; i ++)
13 {
14 if(!col[i] && !lc[n - cur - 1 + i] && !rc[cur + i])
15 {
16 col[i] = lc[n - cur - 1 + i] = rc[cur + i] = true;
17 DFS(cur + 1, n);
18 col[i] = lc[n - cur - 1 + i] = rc[cur + i] = false;
19 }
20 }
21 }
22 int totalNQueens(int n) {
23 ans = 0;
24 col.resize(n, 0);
25 lc.resize(n << 1, 0);
26 rc.resize(n << 1, 0);
27 DFS(0, n);
28 return ans;
29 }
30 };
同上
1 class Solution {
2 public:
3 vector<string> tmp;
4 vector<vector<string> > res;
5 vector<bool> col, lc, rc;
6 void DFS(int cur, int n)
7 {
8 if(cur == n)
9 {
10 res.push_back(tmp);
11 return;
12 }
13 string now(n, '.');
14 for(int i = 0; i < n; i ++)
15 {
16 if(!col[i] && !lc[n - cur - 1 + i] && !rc[cur + i])
17 {
18 col[i] = lc[n - cur - 1 + i] = rc[cur + i] = true;
19 now[i] = 'Q';
20 tmp.push_back(now);
21 DFS(cur + 1, n);
22 tmp.pop_back();
23 now[i] = '.';
24 col[i] = lc[n - cur - 1 + i] = rc[cur + i] = false;
25 }
26 }
27 }
28 vector<vector<string> > solveNQueens(int n) {
29 col.resize(n, 0);
30 lc.resize(n << 1, 0);
31 rc.resize(n << 1, 0);
32 DFS(0, n);
33 return res;
34 }
35 };
Pow(x, n)
很多人用特判错过了 n = -2147483648 这么优美的 trick，而不特判的话，似乎只能 long long 了。
经典的快速幂，用二进制理解也好，用折半理解也好，网上很多资料。
1 class Solution {
2 public:
3 double pow(double x, int n) {
4 double res = 1;
5 long long nn = n;
6 if(nn < 0) x = 1 / x, nn = -nn;
7 while(nn)
8 {
9 if(nn & 1) res *= x;
10 x *= x;
11 nn >>= 1;
12 }
13 return res;
14 }
15 };
Anagrams
这概念以前没听过诶。。题也没看到样例，不知道以后会不会更新，网上查了才明白啥意思。
调换单词字母顺序能一致的单词集合全放进答案。比如有tea, eat, aet，就都要放进答案，有cat, atc，就都要放进答案，而如果孤零零有个dog，没其他可和他一组的，那么就不放进答案。
手写hash能更快些，但是题目没给数据范围，给hash数组定多大都没合理性，干脆用unordered_map好了。
1 class Solution {
2 public:
3 vector<string> res;
4 vector<string> anagrams(vector<string> &strs) {
5 unordered_map<string, int> mp;
6 for(int i = 0; i < strs.size(); i ++)
7 {
8 string tmp = strs[i];
9 sort(tmp.begin(), tmp.end());
10 if(!mp.count(tmp)) mp[tmp] = 0;
11 else mp[tmp] ++;
12 }
13 for(int i = 0; i < strs.size(); i ++)
14 {
15 string tmp = strs[i];
16 sort(tmp.begin(), tmp.end());
17 if(mp.count(tmp) && mp[tmp] > 0) res.push_back(strs[i]);
18 }
19 return res;
20 }
21 };
四个一组，就地旋转。
1 class Solution {
2 public:
3 void rotate(vector<vector<int> > &matrix) {
4 if(matrix.size() == 0) return;
5 int len = matrix.size();
6 int lenlimi = len + 1 >> 1;
7 for(int i = 0; i < lenlimi; i ++)
8 for(int j = 0; j < (len & 1 ? lenlimi - 1 : lenlimi); j ++)
9 {
10 int tmp = matrix[i][j];
11 matrix[i][j] = matrix[len - j - 1][i];
12 matrix[len - j - 1][i] = matrix[len - i - 1][len - j - 1];
13 matrix[len - i - 1][len - j - 1] = matrix[j][len - i - 1];
14 matrix[j][len - i - 1] = tmp;
15 }
16 }
17 };
Permutations II
有重复数字，把数字统计起来好了。因为题目没说数字大小，所以统计用了unordered_map。
也可以把数组排序，DFS时跳过重复的数字。
1 class Solution {
2 public:
3 unordered_map<int, int> mp;
4 vector<int> tmp;
5 vector<vector<int> > res;
6 int numsize;
7 void DFS(int cnt)
8 {
9 if(cnt == numsize)
10 {
11 res.push_back(tmp);
12 }
13 for(unordered_map<int, int>::iterator it = mp.begin(); it != mp.end(); it ++)
14 {
15 if(it->second != 0)
16 {
17 tmp.push_back(it->first);
18 it->second --;
19 DFS(cnt + 1);
20 tmp.pop_back();
21 it->second ++;
22 }
23 }
24 }
25 vector<vector<int> > permute(vector<int> &num) {
26 numsize = num.size();
27 for(int i = 0; i < num.size(); i ++)
28 {
29 if(!mp.count(num[i])) mp[num[i]] = 1;
30 else mp[num[i]] ++;
31 }
32 DFS(0);
33 return res;
34 }
35 };
Permutations
虽然题目没说有没有重复数字。。既然 Permutations II 说有了，那就当这个没有吧。
传统DFS。
1 class Solution {
2 public:
3 vector<vector<int> > res;
4 void DFS(int cur, vector<int> &num)
5 {
6 if(cur == num.size())
7 {
8 res.push_back(num);
9 return;
10 }
11 for(int i = cur; i < num.size(); i ++)
12 {
13 swap(num[cur], num[i]);
14 DFS(cur + 1, num);
15 swap(num[cur], num[i]);
16 }
17 }
18 vector<vector<int> > permute(vector<int> &num) {
19 DFS(0, num);
20 return res;
21 }
22 };
Jump Game II
维护一步最远到达的位置，到达这个位置之前的位置需要的步数都是一样的，到达这个位置的时候，下一步的最远位置已经更新完毕。
1 class Solution {
2 public:
3 int jump(int A[], int n) {
4 int nex = 0, pace = 0, far = 0;
5 for(int i = 0; i <= nex && i < n - 1; i ++)
6 {
7 far = max(far, A[i] + i);
8 if(i == nex)
9 {
10 pace ++;
11 nex = far;
12 }
13 }
14 return pace;
15 }
16 };
同步扫描两个字符串，每当 p 遇到 '*' ，记录s和p的当前扫描位置，当 s 与 p 不匹配时，跑扫描指针回到 '*' 后一个字符， s 扫描指针回到上次遇到 '*' 之后与 p 开始匹配位置的下一个位置。
1 class Solution {
2 public:
3 bool isMatch(const char *s, const char *p) {
4 int last_star = -1, last_s = -1, i, j;
5 for(i = j = 0; s[i]; )
6 {
7 if(s[i] == p[j] || p[j] == '?') i ++, j ++;
8 else if(p[j] == '*') last_star = ++ j, last_s = i;
9 else if(last_star != -1) i = ++ last_s, j = last_star;
10 else return false;
11 }
12 while(p[j] == '*') j ++;
13 return !s[i] && !p[j];
14 }
15 };
Multiply Strings
翻转num1和num2，大整数乘法，把结果再翻转。注意 int 和 char 的转换。
1 class Solution {
2 public:
3 string multiply(string num1, string num2) {
4 string ans(num1.length() + num2.length() + 1, 0);
5 reverse(num1.begin(), num1.end());
6 reverse(num2.begin(), num2.end());
7 int cur = 0, i, j, k;
8 for(i = 0; i < num1.length(); i ++)
9 {
10 for(j = 0; j < num2.length(); j ++)
11 {
12 ans[i + j] += cur + (num1[i] - '0') * (num2[j] - '0');
13 cur = ans[i + j] / 10;
14 ans[i + j] %= 10;
15 }
16 for(k = i + j; cur; k ++)
17 {
18 ans[k] += cur;
19 cur = ans[k] / 10;
20 ans[k] %= 10;
21 }
22 }
23 for(k = ans.length() - 1; k > 0 && ans[k] == 0; k --);
24 ans.resize(k + 1);
25 for(int i = 0; i < ans.length(); i ++) ans[i] += '0';
26 reverse(ans.begin(), ans.end());
27 return ans;
28 }
29 };
Trapping Rain Water
对于每个位置，取这个位置“左边最高的”和“右边最高的”的”较低者“，如果“较低者”比这个位置高，则这个位置存水高度为“较低者”减该位置高度。
1 class Solution {
2 public:
3 int trap(int A[], int n) {
4 vector<int> pre;
5 int i, maxheight, ans;
6 for(i = maxheight = 0; i < n; i ++)
7 {
8 maxheight = max(A[i], maxheight);
9 pre.push_back(maxheight);
10 }
11 for(maxheight = ans = 0, i = n - 1; i > 0; i --)
12 {
13 maxheight = max(A[i], maxheight);
14 ans += max(0, min(pre[i] - A[i], maxheight - A[i]));
15 }
16 return ans;
17 }
18 };
First Missing Positive
题目要求时间O(n)，空间O(1)，经分析，不得不破坏原数组 A。
方法一：
剔除非整数，把原数组 A 当作存在标记，存在的数 x 则 A[x-1]取负数。
1 class Solution {
2 public:
3 int firstMissingPositive(int A[], int n) {
4 int i, j;
5 for(i = j = 0; i < n; i ++)
6 if(A[i] > 0) A[j ++] = A[i];
7 for(i = 0; i < j; i ++)
8 if(abs(A[i]) <= j) A[abs(A[i]) - 1] = -abs(A[abs(A[i]) - 1]);
9 for(i = 0; i < j; i ++)
10 if(A[i] > 0) return i + 1;
11 return j + 1;
12 }
13 };
方法二：
把出现的符合范围的数swap到下标和数对应的位置，再次遍历，数和下标不对应则是第一个没出现的数。注意处理有重复数字。
1 class Solution {
2 public:
3 int firstMissingPositive(int A[], int n) {
4 int i;
5 for(i = 0; i < n; i ++)
6 while(A[i] <= n && A[i] > 0 && A[i] != i + 1 && A[A[i] - 1] != A[i])
7 swap(A[i], A[A[i] - 1]);
8 for(i = 0; i < n; i ++)
9 if(A[i] != i + 1) return i + 1;
10 return i + 1;
11 }
12 };
Combination Sum
基础DFS
1 class Solution {
2 public:
3 vector<int> tmp;
4 vector<vector<int> > ans;
5 void DFS(vector<int> &num, int ith, int now, int target)
6 {
7 if(now == target)
8 {
9 ans.push_back(tmp);
10 return;
11 }
12 if(ith == num.size()) return;
13 int cnt = 0;
14 while(now <= target)
15 {
16 DFS(num, ith + 1, now, target);
17 now += num[ith];
18 cnt ++;
19 tmp.push_back(num[ith]);
20 }
21 while(cnt --) tmp.pop_back();
22 }
23 vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
24 sort(candidates.begin(), candidates.end());
25 DFS(candidates, 0, 0, target);
26 return ans;
27 }
28 };
Combination Sum II
如果一个数没有被用，那么后面重复的这个数就别用，避免重复解。
1 class Solution {
2 public:
3 vector<int> tmp;
4 vector<vector<int> > ans;
5 void DFS(vector<int> &num, int ith, int now, int target)
6 {
7 if(now == target)
8 {
9 ans.push_back(tmp);
10 return;
11 }
12 if(ith == num.size()) return;
13 int nex;
14 for(nex = ith + 1; nex < num.size() && num[nex] == num[ith]; nex ++);
15 DFS(num, nex, now, target);
16 if(num[ith] + now <= target)
17 {
18 now += num[ith];
19 tmp.push_back(num[ith]);
20 DFS(num, ith + 1, now, target);
21 tmp.pop_back();
22 }
23 }
24 vector<vector<int> > combinationSum2(vector<int> &num, int target) {
25 sort(num.begin(), num.end());
26 DFS(num, 0, 0, target);
27 return ans;
28 }
29 };
Count and Say
直接模拟，递推。
1 class Solution {
2 public:
3 string countAndSay(int n) {
4 string f[2];
5 f[0] = "1";
6 for(int i = 1; i < n; i ++)
7 {
8 f[i & 1].clear();
9 for(int j = 0; j < f[i & 1 ^ 1].length();)
10 {
11 int cnt;
12 char x = f[i & 1 ^ 1][j];
13 for(cnt = 0; j < f[i & 1 ^ 1].length() && f[i & 1 ^ 1][j] == x; cnt ++, j ++);
14 f[i & 1] += '0' + cnt;
15 f[i & 1] += x;
16 }
17 }
18 return f[n & 1 ^ 1];
19 }
20 };
Sudoku Solver
这道题考察回溯和数独结果的判断。ACM做过，就直接拿dancing links代码了，4ms。
关于dancing links，对于面试题来说变态了些，应该不至于考察。
1 class Solution {
2 public:
3 int rw[10], cl[10], in[10], RW[81], CL[81], IN[81], goal;
4 char buf[100];
5 void Mark(int i, int num)
6 {
7 rw[RW[i]] ^= 1 << num;
8 cl[CL[i]] ^= 1 << num;
9 in[IN[i]] ^= 1 << num;
10 }
11 void init()
12 {
13 int i;
14 for(i = 0; i < 10; ++ i)
15 cl[i] = rw[i] = in[i] = 0;
16 for(i = goal = 0; buf[i]; ++ i)
17 goal += buf[i] == '.';
18 for(i = 0; i < 81; ++ i)
19 {
20 RW[i] = i / 9, CL[i] = i % 9, IN[i] = i / 3 % 3 + i / 27 * 3;
21 if(buf[i] != '.')
22 Mark(i, buf[i] - '1');
23 }
24 }
25 inline int Judge(int i, int num)
26 {return ~(rw[RW[i]] | cl[CL[i]] | in[IN[i]]) & (1 << num);}
27 int Oper(int sx, int k, int cur)
28 {
29 Mark(sx, k), buf[sx] = k + '1';
30 if(dfs(cur + 1)) return 1;
31 Mark(sx, k), buf[sx] = '.';
32 return 0;
33 }
34 int JudgeRWCLIN(int cur)
35 {
36 int i, j, k, x, cnt, sx;
37 for(i = 0; i < 9; ++ i)
38 for(k = 0; k < 9; ++ k)
39 {
40 if(~rw[i] & (1 << k))
41 {
42 for(j = cnt = 0; j < 9; ++ j)
43 {
44 x = i * 9 + j;
45 if(buf[x] == '.' && Judge(x, k)) ++ cnt, sx = x;
46 }
47 if(cnt == 0) return 0;
48 else if(cnt == 1)
49 return Oper(sx, k, cur);
50 }
51 if(~cl[i] & (1 << k))
52 {
53 for(j = cnt = 0; j < 9; ++ j)
54 {
55 x = j * 9 + i;
56 if(buf[x] == '.' && Judge(x, k)) ++ cnt, sx = x;
57 }
58 if(cnt == 0) return 0;
59 else if(cnt == 1)
60 return Oper(sx, k, cur);
61 }
62 if(~in[i] & (1 << k))
63 {
64 for(j = cnt = 0; j < 9; ++ j)
65 {
66 x = i / 3 * 27 + j / 3 * 9 + i % 3 * 3 + j % 3;
67 if(buf[x] == '.' && Judge(x, k)) ++ cnt, sx = x;
68 }
69 if(cnt == 0) return 0;
70 else if(cnt == 1)
71 return Oper(sx, k, cur);
72 }
73 }
74 return 2;
75 }
76
77
78 bool dfs(int cur)
79 {
80 int i, j, num, cnt;
81 if(cur == goal) return true;
82 for(i = 0; i < 81; ++ i)
83 if(buf[i] == '.')
84 {
85 for(j = cnt = 0; j < 9; ++ j)
86 if(Judge(i, j)) ++ cnt, num = j;
87 if(cnt == 0) return false;
88 if(cnt == 1)
89 return Oper(i, num, cur);
90 }
91 if((num = JudgeRWCLIN(cur)) == 0) return false;
92 else if(num == 1) return true;
93 for(i = 0; i < 81; ++ i)
94 if(buf[i] == '.')
95 {
96 for(j = 0; j < 9; ++ j)
97 if(Judge(i, j))
98 {
99 Mark(i, j), buf[i] = j + '1';
100 if(dfs(cur + 1)) return true;
101 Mark(i, j), buf[i] = '.';
102 }
103 }
104 return false;
105 }
106 void solveSudoku(vector<vector<char> > &board) {
107 int site = 0;
108 for(int i = 0; i < 9; i ++)
109 for(int j = 0; j < 9; j ++)
110 buf[site ++] = board[i][j];
111 init();
112 dfs(0);
113 site = 0;
114 for(int i = 0; i < 9; i ++)
115 for(int j = 0; j < 9; j ++)
116 board[i][j] = buf[site ++];
117 }
118 };
Valid Sudoku
行列九宫格都判断一下。
1 class Solution {
2 public:
3 bool isValidSudoku(vector<vector<char> > &board) {
4 bool flag[3][9][9];
5 memset(flag, false, sizeof(flag));
6 for(int i = 0; i < 9; i ++)
7 {
8 for(int j = 0; j < 9; j ++)
9 {
10 if(board[i][j] != '.')
11 {
12 int x = board[i][j] - '1';
13 if(flag[0][i][x] == true) return false;
14 flag[0][i][x] = true;
15 if(flag[1][j][x] == true) return false;
16 flag[1][j][x] = true;
17 if(flag[2][i / 3 * 3 + j / 3][x] == true) return false;
18 flag[2][i / 3 * 3 + j / 3][x] = true;
19 }
20 }
21 }
22 return true;
23 }
24 };
Search Insert Position
二分
1 class Solution {
2 public:
3 int searchInsert(int A[], int n, int target) {
4 int left, right, mid;
5 for(left = 0, right = n; left < right; )
6 {
7 mid = left + right >> 1;
8 if(A[mid] == target) return mid;
9 if(A[mid] > target) right = mid;
10 else left = mid + 1;
11 }
12 return left;
13 }
14 };
Search for a Range
二分，容易错。可以用lower_bound和upper_bound。
手工代码：
1 class Solution {
2 public:
3 vector<int> searchRange(int A[], int n, int target) {
4 int left, right, mid, l, r;
5 for(left = 0, right = n; left < right; )
6 {
7 mid = left + right >> 1;
8 if(A[mid] >= target) right = mid;
9 else left = mid + 1;
10 }
11 l = left;
12 for(left = 0, right = n; left < right; )
13 {
14 mid = left + right >> 1;
15 if(A[mid] > target) right = mid;
16 else left = mid + 1;
17 }
18 r = left - 1;
19 if(l >= n || A[l] != target) return vector<int>(2, -1);
20 vector<int> ans = {l, r};
21 return ans;
22 }
23 };
STL：
1 class Solution {
2 public:
3 vector<int> searchRange(int A[], int n, int target) {
4 int l = lower_bound(A, A + n, target) - A;
5 int r = upper_bound(A, A + n, target) - A;
6 if(l == n || A[l] != target) return vector<int>(2, -1);
7 vector<int> ans = {l, r - 1};
8 return ans;
9 }
10 };
Search in Rotated Sorted Array
还是二分，但是要判断一下 mid 在哪部分里。
1 class Solution {
2 public:
3 int search(int A[], int n, int target) {
4 int left = 0, right = n - 1, mid;
5 while(left < right)
6 {
7 mid = left + right >> 1;
8 if(A[mid] == target) return mid;
9 if(A[mid] >= A[left])
10 {
11 if(target < A[mid] && A[left] <= target) right = mid;
12 else left = mid + 1;
13 }
14 else
15 {
16 if(target <= A[right] && A[mid] < target) left = mid + 1;
17 else right = mid;
18 }
19 }
20 return A[left] == target ? left : -1;
21 }
22 };
这道题时间限制在O(n)，用一个 stack 实现括号配对+统计, 为了方便实现，写成数组的形式。
对不同深度的括号配对统计个数，一层配对成功把该层统计结果加给上一层，这一层清空。
1 class Solution {
2 public:
3 int longestValidParentheses(string s) {
4 vector<int> cnt(1, 0);
5 int i, ans;
6 for(i = ans = 0; i < s.length(); i ++)
7 {
8 if(s[i] == '(')
9 cnt.push_back(0);
10 else
11 {
12 if(cnt.size() > 1)
13 {
14 cnt[cnt.size() - 2] += *cnt.rbegin() + 2;
15 cnt.pop_back();
16 ans = max(ans, *cnt.rbegin());
17 }
18 else
19 cnt[0] = 0;
20 }
21 }
22 return ans;
23 }
24 };
从后往前找到第一个非降序的 num[i]，再重新从后往前找到第一个比 num[i] 大的，swap(num[i], num[j])，再把 i 之后的排序。
1 class Solution {
2 public:
3 void nextPermutation(vector<int> &num) {
4 int i, j;
5 for(i = num.size() - 2; i >= 0 && num[i] >= num[i + 1]; i --);
6 for(j = num.size() - 1; j > i && num[j] <= num[i]; j --);
7 if(i < j)
8 {
9 swap(num[i], num[j]);
10 sort(num.begin() + i + 1, num.end());
11 }
12 else
13 reverse(num.begin(), num.end());
14 }
15 };
Substring with Concatenation of All Words
直观的方法是枚举起点，判断这个起点下的子串是否合法，O(S.length()*L.size())。
其实可以把 S 分成 L[0].length() 个序列，每个序列都是元素间相隔 L[0].length() 的“string开头”，这些序列互不相干。
如下表，假设 L[0].length()=4，第一行数字为分组组号，第二行数字表示 S 的序号。
| (0) | (1) | (2) | (3) | (0) | (1) | (2) | (3) | (0) | (1) | (2) | (3) | (0) | (1) | (2) | (3) | (0) | (1) | (2) | (3) | (0) |
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
对每个序列，用单调队列的思路来处理，一个一个子串入队，当包含了 L 中所有 string 的时候，保存答案。当新元素入队时超出统计允许时——即 L 中有 3 个 "str", 而这时候遇到第 4 个——则开始出队，一直出到队列里不足 3 个 "str"，然后继续。
这样复杂度为O(L[0].length() * S.length() / L[0].length()) = O(S.length())。目前提交结果是180ms。
1 class Solution {
2 public:
3 vector<int> findSubstring(string S, vector<string> &L) {
4 vector<int> ans;
5 if(L.size() == 0) return ans;
6 unordered_map<string, int> mp, sum;
7 int llen = L[0].length(), i, front, rear;
8 for(int i = 0; i < L.size(); i ++)
9 {
10 if(!mp.count(L[i])) mp[L[i]] = 1;
11 else mp[L[i]] ++;
12 }
13 for(i = 0; i < llen; i ++)
14 {
15 sum = mp;
16 int cnt = 0;
17 for(front = rear = i; front + llen <= S.length(); front += llen)
18 {
19 string tmp = S.substr(front, llen);
20 if(sum.count(tmp))
21 {
22 if(sum[tmp] > 0)
23 {
24 sum[tmp] --;
25 cnt ++;
26 if(cnt == L.size())
27 {
28 ans.push_back(rear);
29 }
30 }
31 else
32 {
33 while(sum[tmp] == 0)
34 {
35 string ntmp = S.substr(rear, llen);
36 sum[ntmp] ++;
37 cnt --;
38 rear += llen;
39 }
40 sum[tmp] --;
41 cnt ++;
42 if(cnt == L.size())
43 {
44 ans.push_back(rear);
45 }
46 }
47 }
48 else
49 {
50 while(rear < front)
51 {
52 string ntmp = S.substr(rear, llen);
53 sum[ntmp] ++;
54 cnt --;
55 rear += llen;
56 }
57 rear += llen;
58 cnt = 0;
59 }
60 }
61 }
62 return ans;
63 }
64 };
Divide Two Integers
假设 dividend 与 divisor 正负一致， divisor^(2^n) 为最接近 dividend 的 divisor 的幂，那么令 newdividend = dividend - divisor^(2^n)，ans = ans + 2^n，问题就更新为 newdividend 除以 divisor，如此迭代。用 divisor^(2^n) 是因为 divisor 不停地辗转加自己就可以得到了。
有 -2147483648 这样的极限数据，因为 int 范围是 -2147483648~+2147483647，发现负数比正数范围“多1”，干脆把所有数都转成负数算，这样就避免用 long long 了。最后考察一下flag。
（如果转成正数的话，int 的 -(-2147483648)还是 -2147483648。。）
1 class Solution {
2 public:
3 int divide(int dividend, int divisor) {
4 bool flag = false;
5 if(divisor > 0) divisor = -divisor, flag ^= true;
6 if(dividend > 0) dividend = -dividend, flag ^= true;
7 int ans = 0, res = divisor, ex = 1;
8 if(divisor < dividend) return 0;
9 while(res >= dividend - res)
10 {
11 res += res;
12 ex += ex;
13 }
14 while(res <= divisor && dividend)
15 {
16 if(res >= dividend)
17 {
18 dividend -= res;
19 ans += ex;
20 }
21 res >>= 1;
22 ex >>= 1;
23 }
24 return flag ? -ans : ans;
25 }
26 };
Implement strStr()
KMP。
1 class Solution {
2 public:
3 char *strStr(char *haystack, char *needle) {
4 int hlen = (int)strlen(haystack), nlen = (int)strlen(needle);
5 if(nlen == 0) return haystack;
6 vector<int> next(nlen + 1);
7 next[0] = -1;
8 for(int i = 0, j = -1; i < nlen;)
9 {
10 if(j == -1 || needle[i] == needle[j])
11 {
12 i ++, j ++;
13 if(needle[i] != needle[j]) next[i] = j;
14 else next[i] = next[j];
15 }
16 else j = next[j];
17 }
18 for(int i = 0, j = 0; i < hlen;)
19 {
20 if(j == -1 || haystack[i] == needle[j])
21 i ++, j ++;
22 else j = next[j];
23 if(j == nlen) return haystack + i - j;
24 }
25 return NULL;
26 }
27 };
Remove Element
两个游标 i, j 异步挪动，把不等于给定值的数往前挪。
1 class Solution {
2 public:
3 int removeElement(int A[], int n, int elem) {
4 int i, j;
5 for(i = j = 0; i < n; i ++)
6 if(A[i] != elem) A[j ++] = A[i];
7 return j;
8 }
9 };
Remove Duplicates from Sorted Array
两个游标 i, j 异步挪动，不重复值往前挪。
1 class Solution {
2 public:
3 int removeDuplicates(int A[], int n) {
4 int i, j;
5 for(i = j = 1; i < n; i ++)
6 if(A[i] != A[i - 1]) A[j ++] = A[i];
7 return n ? j : 0;
8 }
9 };
用头插法来做的，顺序插入到首节点之后，就反转了。每 k 个节点处理之后，把首节指针点移动到下 k 个的开头。最后面不足 k 个的话，再反转回来。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 int Reverse(ListNode *&pre, ListNode *&p, int k)
12 {
13 int i;
14 ListNode *nex, *tmp;
15 for(i = 1; p != NULL; i ++, p = tmp)
16 {
17 if(i == 1) nex = p;
18 tmp = p->next;
19 p->next = pre->next;
20 pre->next = p;
21 if(i == k) i = 0, pre = nex;
22 }
23 nex->next = NULL;
24 return i;
25 }
26 ListNode *reverseKGroup(ListNode *head, int k) {
27 if(head == NULL) return NULL;
28 ListNode *tmphead = new ListNode(0), *pre = tmphead, *p = head;
29 tmphead->next = head;
30 if(Reverse(pre, p, k) != 1)
31 {
32 p = pre->next;
33 Reverse(pre, p, k);
34 }
35 return tmphead->next;
36 }
37 };
Reverse Nodes in k-Group的简化版。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *swapPairs(ListNode *head) {
12 if(head == NULL) return NULL;
13 ListNode *tmphead = new ListNode(0), *pre = tmphead, *p = head, *tmp, *nex;
14 tmphead->next = head;
15 for(int i = 0; p != NULL; i ++, p = tmp)
16 {
17 if(i & 1 ^ 1) nex = p;
18 tmp = p->next;
19 p->next = pre->next;
20 pre->next = p;
21 if(i & 1) pre = nex;
22 }
23 nex->next = NULL;
24 return tmphead->next;
25 }
26 };
Merge k Sorted Lists
一个堆（这里用了优先级队列），把所有 list 的首元素放堆里，O(logn)取得最小值插入新队列，异步推进。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 struct comp
12 {
13 bool operator()(ListNode *a,ListNode *b)
14 {return a->val > b->val;}
15 };
16 ListNode *mergeKLists(vector<ListNode *> &lists) {
17 ListNode *tmphead = new ListNode(0), *p = tmphead;
18 priority_queue<ListNode*, vector<ListNode*>, comp> q;
19 for(int i = 0; i < lists.size(); i ++)
20 if(lists[i] != NULL) q.push(lists[i]);
21 while(!q.empty())
22 {
23 p->next = q.top();
24 p = p->next;
25 q.pop();
26 if(p ->next != NULL) q.push(p->next);
27 }
28 return tmphead->next;
29 }
30 };
Generate Parentheses
DFS，保持当前右括号不多于左括号。
1 class Solution {
2 public:
3 string tmp;
4 vector<string> ans;
5 void DFS(int left, int right, int n)
6 {
7 if(left == right && left == n)
8 {
9 ans.push_back(tmp);
10 return;
11 }
12 if(left < n)
13 {
14 tmp[left + right] = '(';
15 DFS(left + 1, right, n);
16 }
17 if(right < left)
18 {
19 tmp[left + right] = ')';
20 DFS(left, right + 1, n);
21 }
22 }
23 vector<string> generateParenthesis(int n) {
24 tmp.resize(n << 1);
25 DFS(0, 0, n);
26 return ans;
27 }
28 };
用栈配对。
1 class Solution {
2 public:
3 bool isValid(string s) {
4 stack<char> st;
5 for(int i = 0; i < s.length(); i ++)
6 {
7 switch(s[i])
8 {
9 case '(': st.push('('); break;
10 case '[': st.push('['); break;
11 case '{': st.push('{'); break;
12 case ')':
13 if(st.empty() || st.top() != '(') return false;
14 st.pop(); break;
15 case ']':
16 if(st.empty() || st.top() != '[') return false;
17 st.pop(); break;
18 case '}':
19 if(st.empty() || st.top() != '{') return false;
20 st.pop(); break;
21
22 }
23 }
24 return st.empty();
25 }
26 };
Remove Nth Node From End of List
两个指针相隔 n 距离，前面的指针到了末尾，后面的指针就是删除的位置。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *removeNthFromEnd(ListNode *head, int n) {
12 ListNode *pre, *slow, *quick;
13 ListNode *newhead = new ListNode(0);
14 newhead->next = head;
15 int i = 0;
16 for(pre = slow = quick = newhead; quick != NULL; i ++)
17 {
18 pre = slow;
19 if(i >= n) slow = slow->next;
20 quick = quick->next;
21 }
22 pre->next = slow->next;
23 free(slow);
24 return newhead->next;
25 }
26 };
Letter Combinations of a Phone Number
基础DFS。
1 class Solution {
2 public:
3 const vector<string> v = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
4 vector<string> ans;
5 string tmp;
6 void DFS(int cur, string d)
7 {
8 if(cur == d.length())
9 {
10 ans.push_back(tmp);
11 return;
12 }
13 for(int i = 0; i < v[d[cur] - '0'].length(); i ++)
14 {
15 tmp[cur] = v[d[cur] - '0'][i];
16 DFS(cur + 1, d);
17 }
18 }
19 vector<string> letterCombinations(string digits) {
20 tmp.resize(digits.length());
21 DFS(0, digits);
22 return ans;
23 }
24 };
4Sum
尝试了O(n^2)的，但是应该常数很大吧，超时了。就是哈希存两两的和，然后通过查哈希表找到 两两+两两，要判断数字重复情况。这题数据量挺大的，O(n^3)如果用不太好的方式实现的话也会超。
O(n^3)方法：先对num排序，然后从两头枚举两个数，O(n^2)，后两个数在前两个数之间的两端开始，和小了左边的往右，和大了右边的往左调整，O(n)，总共O(n^3)。
1 class Solution {
2 public:
3 vector<vector<int> > ans;
4 vector<vector<int> > fourSum(vector<int> &num, int target) {
5 if(num.size() < 4) return ans;
6 sort(num.begin(), num.end());
7 for(int left = 0; left < num.size() - 3;)
8 {
9 for(int right = num.size() - 1; right > left + 2;)
10 {
11 int ml = left + 1, mr = right - 1;
12 while(ml < mr)
13 {
14 int tmpsum = num[left] + num[right] + num[ml] + num[mr];
15 if(tmpsum > target) mr --;
16 else if(tmpsum < target) ml ++;
17 else
18 {
19 vector<int> tmp = {num[left], num[ml], num[mr], num[right]};
20 ans.push_back(tmp);
21 ml ++;
22 mr --;
23 }
24 for(; ml != left + 1 && ml < mr && num[ml] == num[ml - 1]; ml ++);
25 for(; mr != right - 1 && ml < mr && num[mr] == num[mr + 1]; mr --);
26 }
27 for(right --; right > left + 2 && num[right] == num[right + 1]; right --);
28 }
29 for(left ++; left < num.size() - 3 && num[left] == num[left - 1]; left ++);
30 }
31 return ans;
32 }
33 };
3Sum Closest
O(n^2)，先排序，枚举第一个数，后两个数一个在第一个数后边一个开始，一个从 末尾开始，和4Sum类似调整。
1 class Solution {
2 public:
3 int threeSumClosest(vector<int> &num, int target) {
4 bool findans = false;
5 int ans;
6 sort(num.begin(), num.end());
7 for(int i = 0; i < num.size(); i ++)
8 {
9 for(int left = i + 1, right = num.size() - 1; left < right;)
10 {
11 int tmpsum = num[i] + num[left] + num[right];
12 if(tmpsum > target) right --;
13 else if(tmpsum < target) left ++;
14 else return tmpsum;
15 if(!findans || abs(tmpsum - target) < abs(ans - target))
16 ans = tmpsum, findans = true;
17 }
18 }
19 return ans;
20 }
21 };
3Sum
同上。
1 class Solution {
2 public:
3 vector<vector<int> > ans;
4 vector<vector<int> > threeSum(vector<int> &num) {
5 if(num.size() < 3) return ans;
6 sort(num.begin(), num.end());
7 for(int i = 0; i < num.size();)
8 {
9 for(int left = i + 1, right = num.size() - 1; left <right;)
10 {
11 int tmpsum = num[i] + num[left] + num[right];
12 if(tmpsum < 0) left ++;
13 else if(tmpsum > 0) right --;
14 else
15 {
16 vector<int> tmp = {num[i], num[left], num[right]};
17 ans.push_back(tmp);
18 left ++;
19 right --;
20 }
21 for(; left != i + 1 && left < right && num[left] == num[left - 1]; left ++);
22 for(; right != num.size() - 1 && left < right && num[right] == num[right + 1]; right --);
23 }
24 for(i ++; i < num.size() && num[i] == num[i - 1]; i ++);
25 }
26 return ans;
27 }
28 };
Longest Common Prefix
一个一个扫
1 class Solution {
2 public:
3 string ans;
4 string longestCommonPrefix(vector<string> &strs) {
5 if(strs.size() == 0) return ans;
6 if(strs.size() == 1) return strs[0];
7 for(int j = 0; ; j ++)
8 {
9 for(int i = 1; i < strs.size(); i ++)
10 if(strs[i].size() == j || strs[i][j] != strs[i - 1][j]) return ans;
11 ans += strs[0][j];
12 }
13 return ans;
14 }
15 };
各有各的方法，重点是记录“上一个”数比“这个”数大或小，来确定谁减谁。基本是右结合的，所以从后往前扫好处理些。
class Solution {
public:
int ro[128];
int romanToInt(string s) {
ro['I'] = 1;
ro['V'] = 5;
ro['X'] = 10;
ro['L'] = 50;
ro['C'] = 100;
ro['D'] = 500;
ro['M'] = 1000;
int ans = -1, last;
for(int i = s.length() - 1; i >= 0; i --)
{
if(ans == -1) ans = ro[s[i]];
else
{
if(last > ro[s[i]]) ans -= ro[s[i]];
else ans += ro[s[i]];
}
last = ro[s[i]];
}
return ans;
}
};
Integer to Roman
每个十进制位格式是一样的，只是字母替换一下。
1 class Solution {
2 public:
3 vector<string> table = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
4 string ro = "IVXLCDM";
5 char convert(char x, int i)
6 {
7 if(x == 'I') return ro[i];
8 if(x == 'V') return ro[i + 1];
9 if(x == 'X') return ro[i + 2];
10 }
11 string intToRoman(int num) {
12 string ans;
13 for(int i = 0; num; i += 2, num /= 10)
14 {
15 int x = num % 10;
16 string tmp = table[x];
17 for(int j = 0; j < tmp.size(); j ++)
18 tmp[j] = convert(tmp[j], i);
19 ans = tmp + ans;
20 }
21 return ans;
22 }
23 };
从两端开始枚举，较高的挡板往中间枚举的话一定无法得到更优解，故反复从较低挡板向中间枚举，O(n)。
1 class Solution {
2 public:
3 int maxArea(vector<int> &height) {
4 int left = 0, right = height.size() - 1, ans = -1;
5 while(left < right)
6 {
7 ans = max(ans, min(height[left], height[right]) * (right - left));
8 if(height[left] < height[right]) left ++;
9 else right --;
10 }
11 return ans;
12 }
13 };
Regular Expression Matching
每遇到一个 '*' ，问题都会出现分枝，需要用到栈或者递归。
没有 '*' 的情况好处理，遇到 '*' 的时候，穷举所有匹配长度。
1 class Solution {
2 public:
3 bool isMatch(const char *s, const char *p) {
4 if(*p == 0) return *s == 0;
5 if(*(p + 1) != '*')
6 {
7 if(*s && (*s == *p || *p == '.'))
8 return isMatch(s + 1, p + 1);
9 return false;
10 }
11 else
12 {
13 for(; *s && (*s == *p || *p == '.'); s ++)
14 if(isMatch(s, p + 2)) return true;
15 return isMatch(s, p + 2);
16 }
17 }
18 };
Palindrome Number
首先处理负数的trick。然后主要思路就是通过 while(...) a = a * 10 + x % 10; 来将 x 翻转。
但是注意到 x 很大的时候，翻转的 x 会超出 int 范围，也许会刚好成为另一个和 a 得出的数相等的正数，所以不能完全翻转后判断，而可以在翻转恰好一半的时候判断。
1 class Solution {
2 public:
3 bool isPalindrome(int x) {
4 if(x < 0) return false;
5 if(x == 0) return true;
6 int a = 0, b = x, cnt = 1;
7 while(x /= 10) cnt ++;
8 for(; b && cnt >= 0; b /= 10, cnt -= 2)
9 {
10 if(cnt == 1) return a == b / 10;
11 else if(cnt == 0) return a == b;
12 a = a * 10 + b % 10;
13 }
14 return false;
15 }
16 };
String to Integer (atoi)
任何类似多符号、符号数字间有空格的小问题都直接输出 0，这就好办了。处理越界用 long long。
1 class Solution {
2 public:
3 int atoi(const char *str) {
4 long long ans = 0;
5 bool flag = false;
6 for(; *str == ' '; str ++);
7 if(*str == '+') str ++;
8 else if(*str == '-') flag = true, str ++;
9 for(; isdigit(*str); str ++)
10 {
11 ans = ans * 10 + *str - '0';
12 if((flag ? -ans : ans) > INT_MAX) return INT_MAX;
13 else if((flag ? -ans : ans) < INT_MIN) return INT_MIN;
14 }
15 return (int)(flag ? -ans : ans);
16 }
17 };
Reverse Integer
还是关于越界的讨论，不过这道题本身没有设置处理方式，重点在于面试时的交流。
1 class Solution {
2 public:
3 int reverse(int x) {
4 int a = 0;
5 for( int b = x >= 0 ? x : -x; b; b /= 10)
6 a = a * 10 + b % 10;
7 return x >= 0 ? a : -a;
8 }
9 };
题意的 "z" 字形指一列nRows个，然后斜着往右上一格一个回到第一行，然后再一列nRows个。比如nRows=5，如下：
| 1 | 9 | 17 | 25 | |||||||||||
| 2 | 8 | 10 | 16 | 18 | 24 | 26 | ||||||||
| 3 | 7 | 11 | 15 | 19 | 23 | 27 | … | |||||||
| 4 | 6 | 12 | 14 | 20 | 22 | 28 | 30 | |||||||
| 5 | 13 | 21 | 29 |
每行字母在原字符串中的间隔是有规律的，虽然两层for循环，但是s中每个字母只访问了一次，O(n)。
1 class Solution {
2 public:
3 string convert(string s, int nRows) {
4 if(nRows == 1) return s;
5 string ans;
6 int a = (nRows << 1) - 2, b = 0;
7 for(int i = 0; i < nRows; i ++, a -= 2, b += 2)
8 {
9 bool flag = false;
10 for(int j = i; j < s.length();
11 j += flag ? (b ? b : a) : (a ? a : b), flag ^= 1)
12 ans += s[j];
13 }
14 return ans;
15 }
16 };
网上O(n)的方法是厉害啊。。。简单解释如下：
1、预处理字符串，前后加“哨兵”字符比如 '!'，每个字母旁边加辅助字符比如'#'，这样例如字符串 s = "ababbcbb" 就变成 tmp = "!#a#b#a#b#b#c#b#b#!"。这样的好处是不用讨论回文串长度的奇偶。
2、对转化后的串，维护一个 center 和一个 reach，center 是当前已发现的 reach 最远的回文串中心位置，reach 是这个回文串最右端的位置，center和reach可初始化为 1，即第一个'#'的位置。
3、维护一个数组 vector<int> r(tmp.length())，r[i] 表示 i 位置为中心的回文串半径。
4、在考察位置 i 的时候，所有 j < i 的 r[j] 都是已知的子问题。如果 i 在 reach 的左边，则 i 包含在以 center 为中心的回文串中，那么可以想到，如果和 i 关于 center 对称位置的 mirrori 为中心的回文串覆盖范围没有到达 center 为中心的回文串边缘，则 i 为中心的回文串肯定和 mirrori 的一样。而如果 mirrori 的回文串到达了边缘甚至超过，或者 i 本来就在 reach 的右边，那么对 i 为中心的回文串进行一次扩展，则结果 或者刚好不扩展，或者一定更新了reach。无论怎样，这里都得到了 r[i]。知道了所有 r[i]，答案就出来了。
核心问题在于第4步“对 i 为中心的回文串进行扩展”的复杂度。每次发生“对 i 扩展“，必然是对 reach 的扩展(也可能刚好不扩展，这个不影响复杂度），而 reach 的扩展范围是 tmp 的长度大约 2n，所以总复杂度为 O(n)。
1 class Solution {
2 public:
3 string longestPalindrome(string s) {
4 int center = 1, reach = 1, ansstart = 0, anslength = 0;
5 string tmp = "!#";
6 for(int i = 0; i < s.length(); i ++)
7 tmp += s[i], tmp += '#';
8 tmp + '!';
9 vector<int> r(tmp.length());
10 for(int i = 2; i < tmp.length(); i ++)
11 {
12 int mirrori = center * 2 - i;
13 r[i] = reach > i ? min(r[mirrori], reach - i) : 0;
14 for(; tmp[i + r[i] + 1] == tmp[i - r[i] - 1]; r[i] ++);
15 if(i + r[i] > reach) reach = i + r[i], center = i;
16 if(r[i] > anslength)
17 {
18 ansstart = i - r[i] >> 1;
19 anslength = r[i];
20 }
21 }
22 return s.substr(ansstart, anslength);
23 }
24 };
Add Two Numbers
大整数加法的链表版。
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
12 ListNode *ans = new ListNode(0), *p = ans;
13 int cur = 0;
14 while(l1 != NULL || l2 != NULL || cur)
15 {
16 p->val = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + cur;
17 cur = p->val / 10;
18 p->val %= 10;
19 if(l1) l1 = l1->next;
20 if(l2) l2 = l2->next;
21 if(l1 || l2 || cur)
22 p->next = new ListNode(0);
23 p = p->next;
24 }
25 return ans;
26 }
27 };
Longest Substring Without Repeating Characters
维护一个不重复字符的区间。
代码一：
1 class Solution {
2 public:
3 int lengthOfLongestSubstring(string s) {
4 vector<bool> isin(128, false);
5 int ans = 0;
6 for(int front = 0, rear = 0; front < s.length(); front ++)
7 {
8 if(isin[s[front]])
9 for(; rear < front && isin[s[front]]; isin[s[rear]] = false, rear ++);
10 isin[s[front]] = true;
11 ans = max(ans, front - rear + 1);
12 }
13 return ans;
14 }
15 };
代码二：
1 class Solution {
2 public:
3 int lengthOfLongestSubstring(string s) {
4 vector<int> site(128, -1);
5 int nowstart = -1, ans = 0;
6 for(int i = 0; i < s.length(); i ++)
7 {
8 if(site[s[i]] >= nowstart)
9 nowstart = site[s[i]] + 1;
10 site[s[i]] = i;
11 ans = max(i - nowstart + 1, ans);
12 }
13 return ans;
14 }
15 };
Median of Two Sorted Arrays
如果 A[pa] < B[pb]，那么 A[pa] 一定在 A 与 B 合并后的前 pa + pb + 2 个数中。
证明： A 中有 pa + 1 个数 <= A[pa]，B 中有小于 pb + 1 个数 <= A[pa]，合并后有少于pa + pb + 2 个数 <= A[pa]。
利用这个性质迭代找 A 与 B 合并后的第 k 大数。
1 class Solution {
2 public:
3 int findKth(int A[], int m, int B[], int n, int k)
4 {
5 int pm, pn;
6 while(true)
7 {
8 if(m == 0) return B[k - 1];
9 if(n == 0) return A[k - 1];
10 if(k == 1) return min(A[k - 1], B[k - 1]);
11 if(m <= n) pm = min(k >> 1, m), pn = k - pm;
12 else pn = min(k >> 1, n), pm = k - pn;
13 if(A[pm - 1] < B[pn - 1]) A += pm, m -= pm, k -= pm;
14 else if(A[pm - 1] > B[pn - 1]) B += pn, n -= pn, k-= pn;
15 else break;
16 }
17 return A[pm - 1];
18 }
19 double findMedianSortedArrays(int A[], int m, int B[], int n) {
20 if((m + n) & 1) return findKth(A, m, B, n, (m + n >> 1) + 1);
21 else return (findKth(A, m, B, n, m + n >> 1) +
22 findKth(A, m, B, n, (m + n >> 1) + 1)) * 0.5;
23 }
24 };
Two Sum
哈希存位置，O(n)。
1 class Solution {
2 public:
3 vector<int> twoSum(vector<int> &numbers, int target) {
4 unordered_map<int, int> mp;
5 vector<int> ans;
6 for(int i = 0; i < numbers.size(); i ++)
7 {
8 if(mp.count(target - numbers[i]))
9 {
10 ans.push_back(mp[target - numbers[i]] + 1);
11 ans.push_back(i + 1);
12 break;
13 }
14 if(!mp.count(numbers[i])) mp[numbers[i]] = i;
15 }
16 return ans;
17 }
18 };
来源：https://www.cnblogs.com/CSGrandeur/p/3520937.html