C++博客-Uriel's Corner-文章分类-LeetCode

[LeetCode]Merge Intervals-2014.01.20

Uriel — Mon, 20 Jan 2014 14:40:00 GMT

合并区间，算是经典题了吧，所有区间头尾打乱排序（值相同时区间头排前面！），然后用一个变量记录当前有几重重叠区间，从0->1是为一个合并后的新区间的起始，1->0时为一个合并后的新区间的结束，CE若干次，因为不熟C++，cmp函数写在class里面，WA一次，排序没考虑值相同的情况。。

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
11 struct seg {
12     int fg; //0->start
13     int val;
14 };
15
16 bool cmp(seg a, seg b) {
17     if(a.val != b.val) return a.val < b.val;
18     return a.fg < b.fg;
19 }
20
21 class Solution {
22 public:
23     seg s[100010];
24     vector merge(vector &intervals) {
25         int n = 0;
26         vector res;
27         Interval tp;
28         if(!intervals.size()) return res;
29         for(int i = 0; i < intervals.size(); ++i) {
30             s[n].val = intervals[i].start;
31             s[n].fg = 0;
32             ++n;
33             s[n].val = intervals[i].end;
34             s[n].fg = 1;
35             ++n;
36         }
37         sort(s, s + n, cmp);
38         int nt = 0;
39         for(int i = 0; i < n; ++i) {
40             if(!s[i].fg) {
41                 nt++;
42                 if(nt == 1) tp.start = s[i].val;
43             }
44             else {
45                 nt--;
46                 if(!nt) {
47                     tp.end = s[i].val;
48                     res.push_back(tp);
49                 }
50             }
51         }
52         return res;
53     }
54 };

Uriel 2014-01-20 22:40 发表评论

[LeetCode]Best Time to Buy and Sell Stock II-2014.01.20

Uriel — Mon, 20 Jan 2014 13:51:00 GMT

跟Best Time to Buy and Sell Stock一样，而且可以进行N次买入/卖出操作，于是如果连续两天股票市值之差大于零就累加就行了~

1 class Solution {
2 public:
3     int maxProfit(vector<int> &prices) {
4         int profit[100010], mx = 0, n = prices.size();
5         for(int i = 0; i < n - 1; ++i) {
6             profit[i + 1] = prices[i + 1] - prices[i];
7         }
8         for(int i = 1; i < n; ++i) {
9             if(profit[i] > 0) mx += profit[i];
10         }
11         return mx;
12     }
13 };

Uriel 2014-01-20 21:51 发表评论

[LeetCode]Interleaving String-2014.01.20

Uriel — Mon, 20 Jan 2014 13:12:00 GMT

问string s3是否可由string s1和s2拼成(字母可以穿插)

sample：
s1 = "aabcc",

s2 = "dbbca",

When s3 = "aadbbcbcac", return true.
When s3 = "aadbbbaccc", return false.

DP即可，dp[i][j]表示已匹配s3前i个字符，其中j个字符来自于s1

1 class Solution {
2 public:
3     int dp[1010][1010];
4
5     bool isInterleave(string s1, string s2, string s3) {
6         if(!s1.length()) return s2 == s3;
7         if(!s2.length()) return s1 == s3;
8         int len = s3.length();
9         if(len != s1.length() + s2.length()) return false;
10         memset(dp, 0, sizeof(dp));
11         dp[0][0] = 1;
12         for(int i = 1; i <= len; ++i) {
13             for(int j = 0; j <= i && j <= s1.length(); ++j) {
14                 if(j >= 1 && s1[j - 1] == s3[i - 1] && dp[i - 1][j - 1]) {
15                     dp[i][j] = 1;
16                 }
17                 else if(j >= 0 && j < i && (i - j - 1) < s2.length() && s2[i - j - 1] == s3[i - 1] && dp[i - 1][j]) {
18                     dp[i][j] = 1;
19                 }
20                 if(i == len && dp[i][j]) return true;
21             }
22         }
23         return false;
24     }
25 };

Uriel 2014-01-20 21:12 发表评论

[LeetCode]Best Time to Buy and Sell Stock & Maximum Subarray-2014.01.20

Uriel — Mon, 20 Jan 2014 13:09:00 GMT

Best Time to Buy and Sell Stock

给出n天中每天的股票市值，选定合适的时间买进和卖出一次，问最多赚多少
一开始想都没想O(n^2)暴力一次，果然TLE
然后想到股票市值按日期两两相减，然后就是求最大子段和的问题了。。下面两种写法这题都ok，但做Maximum Subarray这题的时候发现第二种写法是错的，因为存在数列全负的情况！

Maximum Subarray
裸的求最大子段和的问题，跟上题一样。。

1 class Solution {
2 public:
3     int maxProfit(vector<int> &prices) {
4         int profit[100010], dp[100010], mx = 0, tp = 0, n = prices.size();
5         for(int i = 0; i < n - 1; ++i) {
6             profit[i + 1] = prices[i + 1] - prices[i];
7         }
8         dp[0] = 0;
9         for(int i = 1; i < n; ++i) {
10             tp += profit[i];
11             if(tp > mx) {
12                 mx = tp;
13                 dp[i] = mx;
14             }
15             else
16                 dp[i] = dp[i - 1];
17             if(tp < 0) tp = 0;
18         }
19         return mx;
20     }
21 };

1 class Solution {
2 public:
3     int maxProfit(vector<int> &prices) {
4         int profit[100010], dp[100010], mx = 0, n = prices.size();
5         for(int i = 0; i < n - 1; ++i) {
6             profit[i + 1] = prices[i + 1] - prices[i];
7         }
8         dp[0] = 0;
9         for(int i = 1; i < n; ++i) {
10             if(dp[i - 1] + profit[i] < 0) dp[i] = 0;
11             else
12                 dp[i] = dp[i - 1] + profit[i];
13             if(dp[i] > mx) mx = dp[i];
14         }
15         return mx;
16     }
17 };

Uriel 2014-01-20 21:09 发表评论

[LeetCode]Binary Tree Maximum Path Sum-2014.01.19

Uriel — Sun, 19 Jan 2014 13:48:00 GMT

二叉树，每个节点有一个权值，求二叉树上权值和最大的一条路，返回权值和

本来看题目以为是树形DP什么的，结果又是DFS。。没考虑负数情况WA一次。。

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 res;
13
14     int DFS(TreeNode *root, int sum) {
15         if(root == NULL) return INT_MIN;
16         int suml = DFS(root->left, sum);
17         int sumr = DFS(root->right, sum);
18         int tp = root->val;
19         if(suml > 0) tp += suml;
20         if(sumr > 0) tp += sumr;
21         res = max(tp, res);
22         return max(max(suml, sumr), 0) + root->val;
23     }
24
25     int maxPathSum(TreeNode *root) {
26         if(root == NULL) return 0;
27         res = root->val;
28         DFS(root, root->val);
29         return res;
30     }
31 };

Uriel 2014-01-19 21:48 发表评论

[LeetCode]Merge Sorted Array-2014.01.19

Uriel — Sun, 19 Jan 2014 06:27:00 GMT

合并两个已排序数组，WA了几次，因为没判p2>=0这句，自己编译器运行没问题就忽视了。。囧rz

1 class Solution {
2 public:
3     void merge(int A[], int m, int B[], int n) {
4         int pos = m + n - 1, p1 = m - 1, p2 = n - 1;
5         for(int i = pos; i >= 0; --i) {
6             if(p2 >=0 && (p1 < 0 || A[p1] < B[p2])) A[i] = B[p2--];
7             else
8                 A[i] = A[p1--];
9         }
10     }
11 };

Uriel 2014-01-19 14:27 发表评论

[LeetCode]Minimum Path Sum-2014.01.19

Uriel — Sat, 18 Jan 2014 18:57:00 GMT

给一个数字矩阵，求从左上角到右下角数字和最小的一条路径，输出数字和，(每次仅能往右或往下走)

1 class Solution {
2 public:
3     int dp[1010][1010];
4     int minPathSum(vectorint> > &grid) {
5         if(grid.empty()) return 0;
6         for(int i = 0; i < grid.size(); ++i) {
7             for(int j = 0; j < grid[0].size(); ++j) {
8                 if(!i && !j) dp[i][j] = grid[i][j];
9                 else if(!i) dp[i][j] = dp[i][j - 1] + grid[i][j];
10                 else if(!j) dp[i][j] = dp[i - 1][j] + grid[i][j];
11                 else
12                     dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
13             }
14         }
15         return dp[grid.size() - 1][grid[0].size() - 1];
16     }
17 };

Uriel 2014-01-19 02:57 发表评论

[LeetCode]Plus One-2014.01.19

Uriel — Sat, 18 Jan 2014 18:36:00 GMT

用vector表示的一个数，求加1后的数，弱化版高精度加法。。=，=

1 class Solution {
2 public:
3     vector<int> plusOne(vector<int> &digits) {
4         reverse(digits.begin(), digits.end());
5         int n = digits.size();
6         int tp = 1;
7         for(int i = 0; i < n; ++i) {
8             digits[i] += tp;
9             if(digits[i] == 10) {
10                 digits[i] = 0;
11                 tp = 1;
12             }
13             else {
14                 tp = 0;
15                 break;
16             }
17         }
18         if(tp) digits.push_back(tp);
19         reverse(digits.begin(), digits.end());
20         return digits;
21     }
22 };

Uriel 2014-01-19 02:36 发表评论

[LeetCode]Combinations-2014.01.19

Uriel — Sat, 18 Jan 2014 17:36:00 GMT

从1-n中取k个数输出所有取法，就是求组合数啦，还是DFS，跟Subsets II方法一样，但是还是调了一会。。每次写递归脑袋就发晕。。这么多年不曾改变。。简直。。

1 class Solution {
2 public:
3     vectorint>> res;
4     int nt;
5
6     void DFS(int n, int k, vector<int> &tp, int pos) {
7         if(nt == k) {
8             res.push_back(tp);
9             return;
10         }
11         for(int i = pos; i <= n; ++i) {
12             tp.push_back(i);
13             nt++;
14             DFS(n, k, tp, i + 1);
15             tp.pop_back();
16             nt--;
17         }
18     }
19
20     vectorint> > combine(int n, int k) {
21         vector<int> tp;
23         res.clear();
24         nt = 0;
25         DFS(n, k, tp, 1);
26         return res;
27     }
28 };

Uriel 2014-01-19 01:36 发表评论

[LeetCode]Subsets [& ||]-2014.01.18

Uriel — Sat, 18 Jan 2014 16:59:00 GMT

Subsets

求集合S的所有子集，算是位运算应用的题？DFS也行

1 class Solution {
2 public:
3     vectorint> > subsets(vector<int> &S) {
4         vectorint> > res;
5         sort(S.begin(), S.end());
6         for(int i = 0; i < (1 << S.size()); ++i) {
7             vector<int> tp;
8             for(int j = 0; j < S.size(); ++j) {
9                 if((1 << j) & i) tp.push_back(S[j]);
10             }
11             res.push_back(tp);
12         }
13         return res;
14     }
15 };

Subsets II
也是求集合S的所有子集，但是S中可能会有相同元素，所以求的是不重复的子集
位运算枚举然后再判不知道行不行，偷懒用DFS了，然后判重什么的还纠结半天没搞定，参考了下别人的写法

1 class Solution {
2 public:
3     vectorint>> res;
4
5     void DFS(vector<int> &S,vector<int> &tp,int pos) {
6         res.push_back(tp);
7         for(int i = pos; i < S.size(); i++) {
8             while(i != pos && i < S.size() && S[i] == S[i-1]) i++;
9             if(i == S.size()) {
10                 return;
11             }
12             tp.push_back(S[i]);
13             DFS(S, tp, i + 1);
14             tp.pop_back();
15         }
16     }
17
18     vectorint> > subsetsWithDup(vector<int> &S) {
19         vector<int> tp;
20         sort(S.begin(), S.end());
21         res.clear();
22         DFS(S, tp, 0);
23         return res;
24     }
25 };

Uriel 2014-01-19 00:59 发表评论

[LeetCode]Path Sum [& ||]-2014.01.18

Uriel — Sat, 18 Jan 2014 10:06:00 GMT

Path Sum
给一棵二叉树和一个整数，二叉树中每个节点有个权值，每条从根节点到叶节点的路权值求和，问是否存在权值和等于给定数的
BFS，记录权值和，到叶节点的时候判断是否等于给定的数

Path Sum II
上一题的加强版，要输出所有权值和等于给定整数的路径，开个变量记录队列元素之前一个遍历的节点，到叶子节点时若权值和等于给定数，则递归找出路径

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     struct Que {
13         int s, fa;
14         TreeNode *p;
15     }q[100010];
16
17     vectorint> > pathSum(TreeNode *root, int sum) {
18         int l = 0, r = 1;
19         vectorint> > res;
20         res.clear();
21         if(root == NULL) return res;
22         q[0].p = root;
23         q[0].fa = -1;
24         q[0].s = root->val;
25         while(l < r) {
26             if(q[l].p->left == NULL && q[l].p->right == NULL) {
27                 if(q[l].s == sum) {
28                     vector<int> t;
29                     int tp = l;
30                     while(tp >= 0) {
31                         t.push_back(q[tp].p->val);
32                         tp = q[tp].fa;
33                     }
34                     reverse(t.begin(), t.end());
35                     res.push_back(t);
36                 }
37             }
38             if(q[l].p->left != NULL) {
39                 q[r].p = q[l].p->left;
40                 q[r].fa = l;
41                 q[r].s = q[l].s + q[r].p->val;
42                 ++r;
43             }
44             if(q[l].p->right != NULL) {
45                 q[r].p = q[l].p->right;
46                 q[r].fa = l;
47                 q[r].s = q[l].s + q[r].p->val;
48                 ++r;
49             }
50             ++l;
51         }
52         return res;
53     }
54 };

Uriel 2014-01-18 18:06 发表评论

[LeetCode]Sum Root to Leaf Numbers-2014.01.18

Uriel — Sat, 18 Jan 2014 09:49:00 GMT

二叉树每个节点有0-9数值，从二叉树根节点到叶节点确定一个整数，求所有这样的整数之和
例如 1
/ \
2 3
sum=12+13=25
BFS，每个队列元素记录从根到该节点为止的整数大小，每次*10+val，遇到叶节点就累加

Uriel 2014-01-18 17:49 发表评论

[LeetCode]Validate Binary Search Tree-2014.01.18

Uriel — Sat, 18 Jan 2014 09:36:00 GMT

判断一棵树是否是BST，也就是DFS到每个节点判断其左子树节点是否都小于根节点，右子树节点是否都大于根节点，DFS的时候记录左右界

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 res;
13     bool DFS(TreeNode *root, int l, int r) {
14         if(root == NULL) return true;
15         else
16             return root->val > l && root->val < r && DFS(root->left, l, root->val) && DFS(root->right, root->val, r);
17     }
18     bool isValidBST(TreeNode *root) {
19         return DFS(root, -1000000, 1000000);
20     }
21 };

Uriel 2014-01-18 17:36 发表评论

[LeetCode]Minimum Depth of Binary Tree-2014.01.18

Uriel — Sat, 18 Jan 2014 08:56:00 GMT

求二叉树各个叶子节点的最小深度，BFS，记录深度即可，忘记特判空树，又挂一次。。

Uriel 2014-01-18 16:56 发表评论

[LeetCode]Balanced Binary Tree-2014.01.18

Uriel — Sat, 18 Jan 2014 08:55:00 GMT

判断二叉树是否平衡，即其中每一个节点的左右子树深度差不大于1，一开始理解错题意。。。
于是DFS，分别找两颗子树中节点的最大深度，判相差是否不大于1即可

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 res;
13     int DFS(TreeNode *root) {
14         if(!res || root == NULL) return 0;
15         int ld = DFS(root->left);
16         int rd = DFS(root->right);
17         if(abs(ld - rd) > 1) res = false;
18         return max(ld, rd) + 1;
19     }
20
21     bool isBalanced(TreeNode *root) {
22         if(root == NULL) return true;
23         res = true;
24         DFS(root);
25         return res;
26     }
27 };

Uriel 2014-01-18 16:55 发表评论

[LeetCode]Binary Tree Inorder Traversal-2014.01.18

Uriel — Fri, 17 Jan 2014 18:44:00 GMT

裸的中序遍历二叉树，想着用来练记事本直接写代码能力来着，结果CE一次，敲错一个字母...囧

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
14     void inorder(TreeNode *root) {
15         if(root->left != NULL) inorder(root->left);
16         res.push_back(root->val);
17         if(root->right != NULL) inorder(root->right);
18     }
19
20     vector<int> inorderTraversal(TreeNode *root) {
21         res.clear();
22         if(root == NULL) return res;
23         inorder(root);
24         return res;
25     }
26 };

Uriel 2014-01-18 02:44 发表评论

[LeetCode]Surrounded Regions-2014.01.17

Uriel — Fri, 17 Jan 2014 10:16:00 GMT

做的想吐血的一题，交了33次才过，创纪录了...
题目很简单，就是一个字符阵，由X和O构成，找出所有O构成的连通区域，若该区域所有O都在字符阵内部(不在边界上)，则把该连通区域所有O都换成X，其余不变

这题一看到就想着怎么这么裸的DFS，于是想也没想敲完直接RE，看RE返回的是空数据，于是加了判board为空的语句，交上去还是RE，因为之前做LeetCode这种RE的情况都是没有判空，于是换了N种写法判空，还是RE

因为是开了个数组记录字符阵每个元素是否访问过，又开了另一个数组判该连通区域是否邻边，想着是不是数组开太大了，于是试了各种数组大小，发现开bool型，只开一个数组能过，后来想到其实不需要另开一个数组记录是否邻边，搜的时候只搜四边上为O的那些位置，这样一定是邻边的，这个时间复杂度也小一些，于是改了，还是RE，而且挂在大数据上，但是我并没有开数组，不会有越界发生，然后就各种吐血的改来改去，终于AC，虽然还是很莫名...为啥之前会报RE呢？

这是AC的代码：

1 class Solution {
2 public:
3     void DFS(int x, int y, vectorchar>> &board) {
4         int tx, ty;
5         if(x >= board.size() || y >= board[0].size() || x < 0 || y < 0 || board[x][y] != 'O') return;
6         board[x][y] = 'Q';
7         DFS(x, y + 1, board);
8         DFS(x, y - 1, board);
9         DFS(x + 1, y, board);
10         DFS(x - 1, y, board);
11     }
12
13     void solve(vectorchar>> &board) {
14         if(board.empty()) return;
15         int row = board.size();
16         if(!row) return;
17         int col = board[0].size();
18         if(!col) return;
19         for(int i = 0; i < row; ++i) {
20             if(board[i][0] == 'O') DFS(i, 0, board);
21             if(board[i][col - 1] == 'O') DFS(i, col - 1, board);
22         }
23         for(int i = 0; i < col; ++i) {
24             if(board[0][i] == 'O') DFS(0, i, board);
25             if(board[row - 1][i] == 'O') DFS(row - 1, i, board);
26         }
27         for(int i = 0 ; i < row; ++i) {
28             for(int j = 0; j < col; ++j) {
29                 if(board[i][j] == 'Q') board[i][j] = 'O';
30                 else if(board[i][j] == 'O') board[i][j] = 'X';
31             }
32         }
33     }
34
35 };

Uriel 2014-01-17 18:16 发表评论

[LeetCode]Candy-2014.01.17

Uriel — Thu, 16 Jan 2014 18:49:00 GMT

N个人，每个人有个rating，开始分糖，若某个人rating大于其邻居，则拿的糖数也要比那个邻居多，每个人至少一颗糖，问至少要准备多少糖。
从头到尾，从尾到头扫两遍即可

1 class Solution {
2 public:
3     int candy(vector<int> &ratings) {
4         int tp = 1, res = ratings.size(), mi = 1;
5         int can[100010];
6         memset(can, 0, sizeof(can));
7         if(ratings.empty()) return 0;
8         for(int i = 1; i < ratings.size(); ++i) {
9             if(ratings[i] > ratings[i - 1]) {
10                 can[i] = tp++;
11             }
12             else
13                 tp = 1;
14         }
15         tp = 1;
16         for(int i = ratings.size() - 2; i >= 0; --i) {
17             if(ratings[i] > ratings[i + 1]) {
18                 can[i] = max(tp++, can[i]);
19             }
20             else
21                 tp = 1;
22         }
23         for(int i = 0; i < ratings.size(); ++i) res += can[i];
24         return res;
25     }
26 };

Uriel 2014-01-17 02:49 发表评论

[LeetCode]Distinct Subsequences-2014.01.16

Uriel — Thu, 16 Jan 2014 11:19:00 GMT

给两个字符串A和B，求A中B出现几次（不需要匹配连续字符）
明显的LCS扩展，虽然还是搞了很久，RE一次数组开太小，以后看这种直接滚动数组。。

1 int dp[2][122010];
2 int numDistinct(string S, string T) {
3     int res = 0;
4     memset(dp, 0, sizeof(dp));
5     dp[0][0] = dp[1][0] = 1;
6     for(int i = 1; i <= S.length(); ++i) {
7         for(int j = 1; j <= T.length(); ++j) {
8             if(S[i - 1] == T[j - 1]) {
9                 dp[i & 1][j] = dp[(i - 1) & 1][j - 1] + dp[(i - 1) & 1][j];
10             }
11             else
12                 dp[i & 1][j] = dp[(i - 1) & 1][j];
13         }
14     }
15     return dp[S.length() & 1][T.length()];
16 }

Uriel 2014-01-16 19:19 发表评论

[LeetCode]Single Number II-2014.01.16

Uriel — Wed, 15 Jan 2014 19:25:00 GMT

前一题的解题报告把这题的也说了。。一堆出现3次的数中找出唯一一个只出现了1次的，就是每位按位累加，然后mod 3，最后剩下的就是，但是WA了好多次，符号略搞。。

1 class Solution {
2 public:
3     int singleNumber(int A[], int n) {
4         unsigned int res = 0;
5         for(int j = 0; j < 32; ++j) {
6             int tp = 0;
7             const unsigned int pos = 1 << j;
8             for(int i = 0; i < n; ++i) {
9                 tp += (A[i] & pos) > 0;
10             }
11             res |= (!(tp % 3)) ? 0 : pos;
12         }
13         return (int)res;
14     }
15 };

另一种比较高大上的做法是开三个变量，分别标记出现过一次，两次，三次的，每处理一个数的时候分别计算异或、与、非[出现三次时前两个变量都为1，取反后利用第三个变量清除该数]，然后第一个变量中剩下的就是只出现过一次的数
代码巨优美~

1 class Solution {
2 public:
3     int singleNumber(int A[], int n) {
4         int tp3, tp1 = 0, tp2 = 0;
5         for(int i = 0; i < n; ++i) {
6             tp2 |= tp1 & A[i];
7             tp1 ^= A[i];
8             tp3 = ~(tp1 & tp2);
9             tp1 &= tp3;
10             tp2 &= tp3;
11         }
12         return tp1;
13     }
14 };

Uriel 2014-01-16 03:25 发表评论

[LeetCode]Single Number-2014.01.16

Uriel — Wed, 15 Jan 2014 19:19:00 GMT

给一堆数，其中只有一个只出现过1次，其他都出现2次，找出那个出现1次的，其实是简单位运算，但是就没往位运算上想，还在纠结怎么可能空间复杂度O(1)，看了解题报告恍然大悟：http://www.cnblogs.com/feiling/p/3349654.html

就是不断做异或运算就好，最后剩下的就是只出现了1次的那个数

1 class Solution {
2 public:
3     int singleNumber(int A[], int n) {
4         int tp = 0;
5         if(!n) return 0;
6         for(int i = 0; i < n; ++i) {
7             tp = tp ^ A[i];
8         }
9         return tp;
10     }
11 };

Uriel 2014-01-16 03:19 发表评论

[LeetCode]Word Break II-2014.01.13

Uriel — Mon, 13 Jan 2014 19:13:00 GMT

这题是Word Break的加强版，要输出所有可能的单词组合，于是想到用DFS，string操作还是不熟啊，搞到吐血之后，还是参照了解题报告的写法：

1 class Solution {
2 public:
3     int max_len, min_len;
4     vector<string> res;
5     vector<string> tp_res;
6
7     void save_sentence() {
8         string s = "";
9         for(int i = tp_res.size() - 1; i >= 0; --i) s += tp_res[i] + string(" ");
10         s.pop_back();
11         res.push_back(s);
12     }
13
14     void sov(string s, unordered_set<string> &dic) {
15         int len = s.size();
16         if(!len) {
17             save_sentence();
18             return;
19         }
20         for(int i = min_len; i <= min(max_len, len); ++i) {
21             string tp = s.substr(len - i);
22             if(dic.find(tp) != dic.end()) {
23                 tp_res.push_back(tp);
24                 sov(s.substr(0, len - i), dic);
25                 tp_res.pop_back();
26             }
27         }
28     }
29
30     vector<string> wordBreak(string s, unordered_set<string> &dic) {
31         res.clear();
32         min_len = 100000, max_len = 0;
33         unordered_set<string>::iterator it;
34         for(it = dic.begin(); it != dic.end(); ++it) {
35             max_len = max_len > it->size() ? max_len : it->size();
36             min_len = min_len < it->size() ? min_len : it->size();
37         }
38         sov(s, dic);
39         return res;
40     }
41 };

Uriel 2014-01-14 03:13 发表评论

[LeetCode]Word Break-2014.01.13

Uriel — Mon, 13 Jan 2014 19:10:00 GMT

问单词串s是否可以由若干单词相连而成（可以重复使用），这题只要判是否可以组成，简单DP即可

1 class Solution {
2 public:
3     int dp[100010];
4     bool wordBreak(string s, unordered_set<string> &dict) {
5         int i, j;
6         memset(dp, -1, sizeof(dp));
7         dp[0] = 0;
8         unordered_set<string>::iterator it;
9         for(i = 0; i <= s.length(); ++i) {
10             for(j = 0, it = dict.begin(); it != dict.end(); ++it, ++j) {
11                 int ll = it->size();
12                 if(dp[i] >= 0 && i + ll <= s.length() && s.substr(i, ll) == *it) {
13                     dp[i + ll] = j;
14                 }
15             }
16         }
17         if(~dp[s.length()]) return true;
18         return false;
19     }
20 };

Uriel 2014-01-14 03:10 发表评论

[LeetCode]Unique Binary Search Trees II-2014.01.12

Uriel — Sun, 12 Jan 2014 07:30:00 GMT

这题跟Unique Binary Search Trees一样，不过还要输出所有可能的树的每一个节点信息，用递归的方式写比较方便
对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 sov(int l, int r) {
13         vector ans;
14         if(l > r) ans.push_back(NULL);
15         else {
16             for(int i = l; i <= r; ++i) {
17                 vector left = sov(l, i - 1);
18                 vector right = sov(i + 1, r);
19                 for(int ll = 0; ll < left.size(); ++ll) {
20                     for(int rr = 0; rr < right.size(); ++rr) {
21                         TreeNode *root = new TreeNode(i);
22                         root->left = left[ll];
23                         root->right = right[rr];
24                         ans.push_back(root);
25                     }
26                 }
27             }
28         }
29         return ans;
30     }
31
32     vector generateTrees(int n) {
33         return sov(1, n);
34     }
35 };

Uriel 2014-01-12 15:30 发表评论

[LeetCode]Unique Binary Search Trees-2014.01.12

Uriel — Sat, 11 Jan 2014 17:16:00 GMT

求n个节点，节点编号为1~n的BST有多少种
水题吧算是，对于n个节点的BST，1~n都有可能是其树根，于是1~n轮流做根，假设此时树根为i，则以i为根的n个节点的BST数目为i-1个节点的BST数目乘以n-i个节点的BST数目

1 class Solution {
2 public:
3     int dp[100010];
4     int numTrees(int n) {
5         dp[0] = dp[1] = 1;
6         for(int i = 2; i <= n; ++i) {
7             dp[i] = 0;
8             for(int j = 1; j <= i; ++j) {
9                 dp[i] += dp[j - 1] * dp[i - j];
10             }
11         }
12         return dp[n];
13     }
14 };

Uriel 2014-01-12 01:16 发表评论

[LeetCode]Gas Station-2014.01.09

Uriel — Fri, 10 Jan 2014 19:01:00 GMT

O(n^2)的会超时，然后优化方法想不出，参考了：http://blog.csdn.net/lbyxiafei/article/details/12183461

1 class Solution {
2 public:
3     int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
4         int sum = 0, cnt = 0, st = 0;
5         for(int i = 0; i < gas.size(); ++i) {
6             sum += gas[i] - cost[i];
7             cnt += gas[i] - cost[i];
8             if(sum < 0) {
9                 sum = 0;
10                 st = (i + 1) % gas.size();
11             }
12         }
13         if(cnt < 0) return -1;
14         return st;
15     }
16 };

Uriel 2014-01-11 03:01 发表评论

[LeetCode]Longest Consecutive Sequence-2014.01.09

Uriel — Fri, 10 Jan 2014 18:57:00 GMT

给定一串数字，求最长的连续数字数目
map的应用？都忘记了map了...看了解题报告算式复习一下？

1 class Solution {
2 public:
3     int longestConsecutive(vector<int> &num) {
4         map<int, int> mp;
5         mp.clear();
6         int n = num.size();
7         for(int i = 0; i < n; ++i) {
8             mp.insert(pair<int, int>(num[i], 1));
9         }
10         int mx = 1, pre_k = 0, pre_v = 0;
11         map<int, int>::iterator it;
12         for(it = mp.begin(); it != mp.end(); ++it) {
13             if(it == mp.begin()) {
14                 pre_k = it->first;
15                 pre_v = it->second;
16                 continue;
17             }
18             if(it->first == pre_k + 1) {
19                 it->second = pre_v + 1;
20                 mx = max(mx, it->second);
21             }
22             pre_k = it->first;
23             pre_v = it->second;
24         }
25         return mx;
26     }
27 };

Uriel 2014-01-11 02:57 发表评论

[LeetCode]Binary Tree Preorder Traversal-2014.01.06

Uriel — Fri, 10 Jan 2014 18:54:00 GMT

裸的二叉树先序遍历
注意判空树！！！

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
11 vector<int> que;
12
13 void pre_order(TreeNode *root) {
14     if(root == NULL) return;
15     que.push_back(root->val);
16     if(root->left != NULL) pre_order(root->left);
17     if(root->right != NULL) pre_order(root->right);
18 }
19
20 class Solution {
21 public:
22     vector<int> preorderTraversal(TreeNode *root) {
23         if(!que.empty()) que.clear();
24         pre_order(root);
25         return que;
26     }
27 };

Uriel 2014-01-11 02:54 发表评论

[LeetCode]Binary Tree Postorder Traversal-2014.01.06

Uriel — Fri, 10 Jan 2014 18:52:00 GMT

裸的二叉树后序遍历
RE无穷多次，注意判空树！！！

/**
* Definition for binary tree
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
    TreeNode *tp[1010];
    vector<int> postorderTraversal(TreeNode *root) {
        int k = 0;
        vector<int> que;
        if(root == NULL) return que;
        TreeNode *p = root, *pre = NULL;
        tp[k++] = p;
        while(k) {
            TreeNode *cur = tp[k - 1];
            if((cur->left == NULL && cur->right == NULL) || (pre != NULL && (pre == cur->left || pre == cur->right))) {
                que.push_back(cur->val);
                --k;
                pre = cur;
            }
            else {
                if(cur->right != NULL) tp[k++] = cur->right;
                if(cur->left != NULL) tp[k++] = cur->left;
            }
        }
        return que;
    }
};

Uriel 2014-01-11 02:52 发表评论

[LeetCode]Evaluate Reverse Polish Notation-2013.12.27

Uriel — Fri, 10 Jan 2014 18:51:00 GMT

一天遇到两次一样的题简直...要是能在之前一天能做一下这题多好，就不至于当时题目问了几遍才明白...
给出逆波兰式，求算式的值，模拟栈，乘除的时候注意出栈顺序！和算式的操作数顺序相反！下午就死在这上面了...

1 class Solution {
2 public:
3     int evalRPN(vector<string> &tokens) {
4         int stk[1010], k = 0;
5         for(int i = 0; i < tokens.size(); ++i) {
6             if(tokens[i] == "+") {
7                 int a = stk[k - 1], b = stk[k - 2];
8                 k -= 2;
9                 stk[k++] = a + b;
10             }
11             else if(tokens[i] == "-") {
12                 int a = stk[k - 1], b = stk[k - 2];
13                 k -= 2;
14                 stk[k++] = b - a;
15             }
16             else if(tokens[i] == "*") {
17                 int a = stk[k - 1], b = stk[k - 2];
18                 k -= 2;
19                 stk[k++] = b * a;
20             }
21             else if(tokens[i] == "/") {
22                 int a = stk[k - 1], b = stk[k - 2];
23                 k -= 2;
24                 stk[k++] = b / a;
25             }
26             else {
27                 stk[k++] = atoi(tokens[i].c_str());
28             }
29         }
30         return stk[0];
31     }
32 };

Uriel 2014-01-11 02:51 发表评论