精品无码久久久久国产,国产精品久久久久久久久,色99久久久久高潮综合影院

[LeetCode]Merge Intervals-2014.01.20

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

合�ƈ区间�Q�算是经兔R��了吧�Q�所有区间头��打乱排序（值相同时区间头排前面�Q�）�Q�然后用一个变量记录当前有几重重叠区间�Q�从0->1是�ؓ一个合�q�后的新区间的�v始，1->0时�ؓ一个合�q�后的新区间的结束，CE若干�ơ，因�ؓ不熟C++�Q�cmp函数写在class里面�Q�WA一�ơ，排序没考虑值相同的情况。�?br />

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一��P��而且可以�q�行N�ơ买�?卖出操作�Q�于是如果连�l�两天股��市��g��差大于零��q��加就行了~

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拼成(字母可以�I�插)

sample�Q?br />s1 = "aabcc",

s2 = "dbbca",

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

DP卛_��Q�dp[i][j]表示已匹配s3前i个字�W�，其中j个字�W�来自于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

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

Maximum Subarray
裸的求最大子�D�和的问题，跟上题一栗��?br />

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

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

本来看题目以为是树�ŞDP什么的�Q�结果又是DFS。。没考虑负数情况WA一�ơ。�?br />

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

合�ƈ两个已排序数�l�，WA了几�ơ，因�ؓ没判p2>=0�q�句�Q�自��q��译器�q�行没问题就忽视了。。囧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

�l�一个数字矩阵，求从左上角到右下角数字和最��的一条�\径，输出数字和，(每次仅能往��x��往下走)

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表示的一个数�Q�求�?后的敎ͼ�弱化版高�_�ֺ�加法。�?�Q?

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

�?-n中取k个数输出所有取法， ��是求组合数啦，�q�是DFS�Q�跟Subsets II�Ҏ��一��P��但是�q�是调了一会。。每�ơ写递归脑袋��发晕。。这么多�q�不曾改变。。简直。�?br />

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中可能会有相同元素，所以求的是不重复的子集
位运��枚丄��后再判不知道行不行，��h��用DFS了，然后判重什么的�q�纠�l�半天没搞定�Q�参考了下别人的写法

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
�l�一��二叉树和一个整敎ͼ�二叉树中每个节点有个权��|��每条从根节点到叶节点的�\权值求和，问是否存在权值和�{�于�l�定数的
BFS�Q�记录权值和�Q�到叶节点的时候判断是否等于给定的�?br />

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

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数��|��从二叉树根节点到叶节点确定一个整敎ͼ�求所有这��L��整数之和
例如 1
/ \
2 3
sum=12+13=25
BFS�Q�每个队列元素记录从根到该节点�ؓ止的整数大小�Q�每��?10+val�Q�遇到叶节点��q��?br />

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

[LeetCode]Validate Binary Search Tree-2014.01.18

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

判断一��|��是否是BST�Q�也��是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�Q�记录深度即可，忘记特判�I�树�Q�又挂一�ơ。�?br />

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

[LeetCode]Balanced Binary Tree-2014.01.18

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

判断二叉树是否��^衡，卛_��中每一个节点的左右子树深度差不大于1�Q�一开始理解错题意。。�?br />于是DFS�Q�分别找两颗子树中节点的最大深度，判相差是否不大于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

裸的中序遍历二叉树，想着用来�l�记事本直接写代码能力来着�Q�结果CE一�ơ，敲错一个字�?..�?br />

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�ơ才�q�，创纪录了...
题目很简单，��是一个字�W�阵�Q�由X和O构成�Q�找出所有O构成的连通区域，若该区域所有O都在字符阵内�?不在边界�?�Q�则把该�q�通区域所有O都换成X�Q�其余不�?br />
�q�题一看到��想着怎么�q�么裸的DFS�Q�于是想也没��x��完直接RE�Q�看RE�q�回的是�I�数据，于是加了判board为空的语句，交上去还是RE�Q�因��Z��前做LeetCode�q�种RE的情况都是没有判�I�，于是换了N�U�写法判�I�，�q�是RE

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

�q�是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个�h�Q�每个�h有个rating�Q�开始分�p�，若某个�hrating大于光��居，则拿的糖��C��要比那个��d��多，每个��一颗糖�Q�问臛_��要准备多��糖�?br />从头到尾�Q�从��ֈ�头扫两遍卛_��

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

�l�两个字�W�串A和B�Q�求A中B出现几次�Q�不需要匹配连�l�字�W�）
明显的LCS扩展�Q�虽然还是搞了很久，RE一�ơ数�l�开太小�Q�以后看�q�种直接滚动数组。�?br />

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

前一题的解题报告把这题的也说了。。一堆出�?�ơ的��C��扑և�唯一一个只出现�?�ơ的�Q�就是每位按位篏加，然后mod 3�Q�最后剩下的��是�Q�但是WA了好多次�Q�符��L��搞。�?br />

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 };

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

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

�l�一堆数�Q�其中只有一个只出现�q?�ơ，其他都出�?�ơ，扑և�那个出现1�ơ的�Q�其实是��单位�q�算�Q�但是就没往位运��上惻I��q�在�U�结怎么可能�I�间复杂度O(1)�Q�看了解题报告恍然大悟：http://www.cnblogs.com/feiling/p/3349654.html

��是不断做异或运��就好，最后剩下的��是只出��C��1�ơ的那个�?br />

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

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

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是否可以��p��q�单词相�q�而成�Q�可以重复��用）�Q�这题只要判是否可以�l�成�Q�简单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

�q�题跟Unique Binary Search Trees一��P��不过�q�要输出所有可能的树的每一个节点信息，用递归的方式写比较方便
对vector�q�很不熟�l�啊...写晕了之后还是参考了一下别人的代码

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个节点，节点�~�号�?~n的BST有多��种
水题吧算是，对于n个节点的BST�Q?~n都有可能是其树根�Q�于�?~n轮流做根�Q�假设此时树根�ؓi�Q�则以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)的会��时�Q�然后优化方法想不出�Q�参考了�Q?a >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

�l�定一串数字，求最长的�q�箋数字数目
map的应用？都忘��C��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

裸的二叉树先序遍�?br />注意判空树！�Q�！

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

裸的二叉树后序遍�?br />RE无穷多次�Q�注意判�I�树�Q�！�Q?br />

/**
* 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

一天遇��C��ơ一��L��题简�?..要是能在之前一天能做一下这题多好，��׃��至于当时题目问了几遍才明�?..
�l�出逆�L兰式�Q�求��式的��|��模拟栈，乘除的时候注意出栈顺序！和算式的操作数顺序相反！下午��死在这上面�?..

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 发表评论