编程之美 on Coinidea的博客

[leetcode]Number Complement

Mon, 09 Mar 2020 13:54:50 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Solution {
public:
 int findComplement(int num) {
 int countDigit = 0;
 int numBak = num;
 while (0 < num) {
 num = num >> 1;
 countDigit++;
 }
 return (int)(pow(2, countDigit) - 1 - numBak);
 }
};

[leetcode]Print in Order

Sun, 23 Feb 2020 04:11:23 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Foo {
private:
 bool isFirst;
 bool isSecond;
 bool isThird;
public:
 Foo() {
 isFirst = false;
 isSecond = false;
 isThird = true;
 }

 void first(std::function<void()> printFirst) {
 while (!isThird);
 isThird = false;
 isSecond = false;
 printFirst();
 // printFirst() outputs "first". Do not change or remove this line.
 isFirst = true;
 }

 void second(std::function<void()> printSecond) {
 while(!isFirst);
 isFirst = false;
 isThird = false;
 // printSecond() outputs "second". Do not change or remove this line.
 printSecond();
 isSecond = true;
 }

 void third(std::function<void()> printThird) {
 while(!isSecond);
 isFirst = false;
 isSecond = false;
 // printThird() outputs "third". Do not change or remove this line.
 printThird();
 isThird = true;
 }
};

[leetcode]First Bad Version

Tue, 18 Jul 2017 14:17:57 +0000

此题就是二分的变种，但是千万要注意大整数求和越界，正确的计算方式应该是 left + (right - left) / 2; 我使用的是 long long.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

class Solution {
public:
 int bSearch(long long left, long long right) {
 if (left >= right) {
 return right;
 }
 long long middle = (left + right) / 2;
 if (!isBadVersion(middle)) {
 if (middle + 1 > right) return middle;
 if (isBadVersion(middle + 1)) return middle + 1;
 else return bSearch(middle, right);
 }
 else {
 return bSearch(left, middle);
 }
 }

 int firstBadVersion(int n) {
 return bSearch(1, n);
 }
};

[leetcode]Palindrome Linked List

Tue, 18 Jul 2017 06:10:24 +0000

此提示单链表判断回文，我本来的思路是逆转单链表前半截，再跑一次，应该能满足时间复杂度 (O(n)) 和空间复杂度 (O(1))，但是不知道为啥老判我超时。
看了 discuss 和 hint，其实简单递归一下就可以了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 ListNode * temp;
 bool isPalindrome(ListNode* head) {
 temp = head;
 return check(head);
 }

 bool check(ListNode * node) {
 if (node == NULL) return true;
 bool flag = check(node->next) && (node->val == temp->val);
 temp = temp->next;
 return flag;
 }
};

[leetcode]Maximum Product Subarray

Mon, 17 Jul 2017 06:34:07 +0000

此题给的是一个数组，求这个数组中的子数组乘积最大值，考虑正负数和0的情况。hint给的解法应该是每个值求一个max和min，然后用max和min来生成算上当前点的最大值和最小值。我自己用了一个模拟。所有数求乘积，如果为正则为最大，如果为负则比较抛弃最左边或最右边的负数。考虑到0的情况，先用0分界。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


class Solution {
public:
 int maxProductNoZero(vector<int>& nums) {
 int max = 1;
 int left = nums.size();
 int right = -1;
 for (int i = 0; i < nums.size(); i++) {
 max *= nums[i];
 if (nums[i] < 0 && i < left) {
 left = i;
 }
 if (nums[i] < 0 && i > right) {
 right = i;
 }
 }
 if (max < 0 && nums.size() > 1) {
 int max_left = 1;
 for (int i = left + 1; i < nums.size(); i++) {
 max_left *= nums[i];
 }
 int max_right = 1;
 for (int i = 0; i < right; i++) {
 max_right *= nums[i];
 }
 max = max_left > max_right ? max_left : max_right;
 }
 return max;
 }

 int maxProduct(vector<int>& nums) {
 int max = nums[0];
 vector<int> zero;
 zero.clear();
 zero.push_back(-1);
 for (int i = 0; i < nums.size(); i++) {
 if (max < nums[i]) {
 max = nums[i];
 }
 if (0 == nums[i]) {
 zero.push_back(i);
 }
 }
 zero.push_back(nums.size());
 for (int i = 0; i < zero.size() - 1; i++) {
 if (zero[i + 1] - 1 >= zero[i] + 1) {
 vector<int> sub;
 sub.clear();
 for (int j = zero[i] + 1; j <= zero[i + 1] - 1; j++) {
 sub.push_back(nums[j]);
 }
 int tmp = maxProductNoZero(sub);
 if (tmp > max) max = tmp;
 }
 }
 return max;
 }
};

[leetcode]Isomorphic Strings

Fri, 14 Jul 2017 03:38:23 +0000

这个题用一个hash存一下两个字符串的对应关系就好了。我开始以为只有小写字母，其实是所有ASCII字符。开始用一个hash存的，后来因为一一对应需要用两个hash存。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 bool isIsomorphic(string s, string t) {
 if (s.length() != t.length()) return false;
 char hash_s[256];
 char hash_t[256];
 memset(hash_s, NULL, 256);
 memset(hash_t, NULL, 256);
 for (int i = 0; i < s.length(); i++) {
 if (NULL == hash_s[s[i]] && NULL == hash_t[t[i]]) {
 hash_s[s[i]] = t[i];
 hash_t[t[i]] = s[i];
 }
 else {
 if (hash_s[s[i]] != t[i] || hash_t[t[i]] != s[i]) return false;
 }
 }
 return true;
 }
};

[leetcode]Two Sum II – Input array is sorted

Fri, 14 Jul 2017 03:34:59 +0000

此题我用的是二分查找，毕竟有序嘛。其实更好的解法，应该是一个数组，left right下标往里移动查找，这个题我曾经应该在《编程之美》或者《剑指Offer》上看到过。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 vector<int> result;

 void bSearch(vector<int>& numbers, int start, int end, int find) {
 if (start > end) return;
 int middle = (start + end) / 2;
 if (find == numbers[middle]) {
 result.push_back(middle + 1);
 return;
 } else if (find > numbers[middle]) {
 bSearch(numbers, middle + 1, end, find);
 } else {
 bSearch(numbers, start, middle - 1, find);
 }
 }

 vector<int> twoSum(vector<int>& numbers, int target) {
 for (int i = 0; i < numbers.size(); i++) {
 int find = target - numbers[i];
 result.push_back(i + 1);
 bSearch(numbers, i + 1, numbers.size(), find);
 if (result.size() == 2) {
 return result;
 }
 result.clear();
 }
 return result;
 }
};

[leetcode]Combine Two Tables

Fri, 14 Jul 2017 03:31:53 +0000

此题就是一个联表查询，不过我当时认为join就是left join，没有用on，用的where结果做成内联了，错了几次。

1
2
3
4


select p.FirstName, p.LastName, a.City, a.State
from Person as p
left join Address as a
on p.PersonId = a.PersonId

[leetcode]Min Stack

Fri, 14 Jul 2017 03:26:49 +0000

快两年没做题了，压力好大，最近练习一下，保持一种感觉。

这个题据说是《剑指Offer》上的一个题，其实我的解法明显有问题，但是还是AC了。我发现PHP、JS、C#写久了，我连Vector都快不会写了。

此题正确的解法应该是用一个栈来维护最小值，是当前最小值即进入一个栈。另一个栈放数据，即可保证复杂度在O(n)，查询复杂度O(1)。

我的解法比较中二：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


class MinStack {
private:
 vector<int> stack;
 int min;
public:
 MinStack() {
 stack.clear();
 }

 void push(int x) {
 if (stack.empty() || min > x) {
 min = x;
 }
 stack.push_back(x);
 }

 void pop() {
 if (!stack.empty()) {
 stack.pop_back();
 genMin();
 }
 }

 void genMin() {
 min = *(stack.begin());
 for (vector<int>::iterator i = stack.begin() + 1; i < stack.end(); i++) {
 if (min > *i) {
 min = *i;
 }
 }
 }

 int top() {
 if (!stack.empty()) {
 return *(stack.end() - 1);
 }
 return false;
 }

 int getMin() {
 return min;
 }
};

[leetcode][PHP实现]Contains Duplicate

Tue, 01 Dec 2015 10:06:29 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


<?php
class Solution
{
 public function containsDuplicate($nums)
 {
 $hashTable = array();
 foreach ($nums as $num)
 {
 if (!array_key_exists($num,$hashTable))
 {
 $hashTable[$num] = 1;
 }
 else
 {
 return false;
 }
 }
 return true;
 }
}
$solution = new Solution();
echo $solution->containsDuplicate(array(2,1,3,4,5,6,7,9));
?>

[leetcode][PHP实现]Excel Sheet Column Number

Mon, 30 Nov 2015 12:25:48 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<?php
class Solution
{
 public function titleToNumber($s)
 {
 $num = 0;
 $len = strlen($s) - 1;
 for ($i = $len; $i >= 0; $i--)
 {
 $num += (ord($s[$i]) - ord('A') + 1) * (int)pow(26, $len - $i);
 }
 return $num;
 }
}
$solution = new Solution();
echo $solution->titleToNumber("AA");
?>

[leetcode][PHP实现]Valid Anagram

Mon, 30 Nov 2015 12:24:46 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


<?php
class Solution
{
 public function isAnagram($s, $t)
 {
 $s = strtolower($s);
 $t = strtolower($t);
 for ($i = 0; $i < 26; $i++)
 {
 $sChars[$i] = 0;
 $tChars[$i] = 0;
 }
 for ($i = 0; $i < strlen($s); $i++)
 {
 $sChars[ord($s[$i]) - ord('a')]++;
 }
 for ($i = 0; $i < strlen($t); $i++)
 {
 $tChars[ord($t[$i]) - ord('a')]++;
 }
 //var_dump($sChars);
 //var_dump($tChars);
 for ($i = 0; $i < 26; $i++)
 {
 if ($sChars[$i] != $tChars[$i])
 {
 return false;
 }
 }
 return true;
 }
}
$solution = new Solution();
echo $solution->isAnagram("HelloWorld", "whelloorld");
?>

[leetcode][PHP实现]Add Digits

Mon, 30 Nov 2015 12:23:52 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


<?php
class Solution
{
 public function addDigits($num)
 {
 while ($num > 10)
 {
 $tmp = 0;
 while ($num > 0)
 {
 $tmp += $num % 10;
 $num = intval($num / 10);
 }
 $num = $tmp;
 }
 return $num;
 }
}
$solution = new Solution();
echo $solution->addDigits(381);
?>

[leetcode][PHP实现]Two Sum

Mon, 30 Nov 2015 12:22:21 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


<?php
class solution
{
 public function twoSum($nums, $target)
 {
 $result = array();
 for ($i = 0; $i < count($nums); $i++)
 {
 for ($j = 0; $j < count($nums); $j++)
 {
 if ($target == $nums[$i] + $nums[$j])
 {
 $result[0] = $i + 1;
 $result[1] = $j + 1;
 return $result;
 }
 }
 }
 return $result;
 }
}
$solution = new Solution();
var_dump($solution->twoSum(array(2,7,11,15), 9));
?>

[leetcode][PHP实现]Single Number

Mon, 30 Nov 2015 12:20:03 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<?php
class Solution
{
 public function singleNumber($nums)
 {
 $single = 0;
 foreach ($nums as $num)
 {
 $single ^= $num;
 echo $num;
 }
 return $single;
 }
}
$solution = new Solution();
echo $solution->singleNumber(array(1,1,2,3,2,4,4,5,3));
?>

[leetcode_213]House Robber II

Fri, 18 Sep 2015 14:45:21 +0000

因为形成了环，遍历每个点为起始点，并排除相邻点，假设起始点必选。借用House Robber的解法即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


class Solution {
public:
 int robOne(vector& nums) {
 if (nums.size() == 0) {
 return 0;
 }
 vector v(nums.size() + 1);
 v[0] = 0;
 v[1] = nums[0];
 for (int i = 1; i < nums.size(); i++) {
 int j = i + 1;
 if (nums[i] + v[j - 2] > v[j - 1]) {
 v[j] = nums[i] + v[j - 2];
 } else {
 v[j] = v[j - 1];
 }
 }
 return v[nums.size()];
 }

 int rob(vector& nums) {
 vector numsc;
 int size = nums.size();
 int sum = 0;
 for (int i = 0; i < size; i++) {
 numsc.clear();
 int tmp = nums[i];
 for (int j = i; j < size; j++) {
 if (j == ((i-1) < 0 ? i - 1 + size : i - 1) ||
 j == ((i+1) >= size ? i + 1 - size : i + 1) ||
 j == i) {
 numsc.push_back(0);
 continue;
 }
 numsc.push_back(nums[j]);
 }
 for (int j = 0; j < i; j++) {
 if (j == ((i-1) < 0 ? i - 1 + size : i - 1) ||
 j == ((i+1) >= size ? i + 1 - size : i + 1) ||
 j == i) {
 numsc.push_back(0);
 continue;
 }
 numsc.push_back(nums[j]);
 }
 tmp += robOne(numsc);
 if (tmp >= sum) {
 sum = tmp;
 }
 }
 return sum;
 }
};

[leetcode_215] Kth Largest Element in an Array

Mon, 14 Sep 2015 12:29:31 +0000

第k大数，取巧了，直接快排了。应该是模拟快排。

1
2
3
4
5
6
7


class Solution {
public:
 int findKthLargest(vector<int>& nums, int k) {
 sort(nums.begin(), nums.end(), greater<int>());
 return nums[k - 1];
 }
};

[leetcode_275]H-Index II

Mon, 14 Sep 2015 12:28:35 +0000

此题虽然能过，但是并未使用o(logn)的解法， mark一下，下次来解。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 int hIndex(vector<int>& citations) {
 //sort(citations.begin(), citations.end(), greater<int>());
 int size = citations.size();
 int max = 0;
 for (int i = size - 1; i >= 0; i--) {
 int j = size - 1 - i;
 if (citations[i] >= j + 1) {
 max = j + 1;
 }
 }
 return max;
 }
};

[leetcode_274]H-Index

Mon, 14 Sep 2015 12:27:38 +0000

降序排列，然后即可线性查找符合条件的h索引。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 int hIndex(vector<int>& citations) {
 sort(citations.begin(), citations.end(), greater<int>());
 int size = citations.size();
 int max = 0;
 for (int i = 0; i < size; i++)
 {
 if (citations[i] >= i + 1)
 {
 max = i + 1;
 }
 }
 return max;
 }
};

[leetcode_154]Find Minimum in Rotated Sorted Array II

Sun, 13 Sep 2015 08:22:43 +0000

与Find Minimum in Rotated Sorted Array解法类似

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
public:
 int min;
 void search(int left, int right, vector<int>& nums)
 {
 if (right < left)
 {
 return;
 }
 int mid = (left + right) / 2;
 if (nums[mid] < min) {
 min = nums[mid];
 search(left, mid - 1, nums);
 search(mid + 1, right, nums);
 } else if (nums[mid] >= min) {
 search(left, mid - 1, nums);
 search(mid + 1, right, nums);
 }
 }

 int findMin(vector<int>& nums) {
 min = nums[0];
 search(0, nums.size() - 1, nums);
 return min;
 }
};

[leetcode_216]Combination Sum III

Sun, 13 Sep 2015 08:20:50 +0000

深度优先搜索。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 vector<vector<int>> result;
 vector<int> list;

 void search(int now, int k, int n, int sum) {
 if (list.size() == k && sum == n) {
 result.push_back(list);
 }
 if (list.size() >= k || now > 9) {
 return;
 }
 list.push_back(now);
 search(now + 1, k , n , sum + now);
 list.pop_back();
 search(now + 1, k , n , sum);
 }

 vector<vector<int>> combinationSum3(int k, int n) {
 result.clear();
 list.clear();

 search(1, k, n, 0);

 return result;
 }
};

[leetcode_240]Search a 2D Matrix II

Sun, 13 Sep 2015 08:20:04 +0000

因为矩阵的特殊性，所有从左上角顶点开始搜索即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 bool searchMatrix(vector<vector<int>>& matrix, int target) {
 int row = matrix.size() - 1;
 int cols = matrix[0].size() - 1;
 int x = 0;
 int y = cols;
 while (x <= row && y >= 0)
 {
 if (target == matrix[x][y])
 {
 return true;
 }
 else if (target > matrix[x][y])
 {
 x++;
 }
 else
 {
 y--;
 }
 }
 return false;
 }
};

[leetcode_230]Kth Smallest Element in a BST

Thu, 10 Sep 2015 14:34:22 +0000

求二叉搜索树的第k个数，中序遍历生成二叉搜索树，存入数组中，然后输出第k个即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
public:
 vector<int> list;
 void queryTree(TreeNode * node)
 {
 if (NULL == node)
 {
 return;
 }
 if (NULL != node->left)
 {
 queryTree(node->left);
 }
 list.push_back(node->val);
 if (NULL != node->right)
 {
 queryTree(node->right);
 }
 }

 int kthSmallest(TreeNode* root, int k) {
 list.clear();
 queryTree(root);
 return list[k-1];
 }
};

[leetcode_219]Contains Duplicate II

Wed, 09 Sep 2015 12:36:36 +0000

求数组中，是否存在两个相同元素的小标差小于k。hash题目。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 bool containsNearbyDuplicate(vector<int>& nums, int k) {
 map<int, int> mNums;
 mNums.clear();
 for (int i = 0;i < nums.size();i++)
 {
 map<int,int>::iterator it = mNums.find(nums[i]);
 if (mNums.end() == it)
 {
 mNums.insert(pair<int,int>(nums[i], i));
 }
 else
 {
 if (i - it->second <= k)
 {
 return true;
 }
 mNums.erase(it);
 mNums.insert(pair<int,int>(nums[i], i));
 }
 }
 return false;
 }
};

[leetcode_223]Rectangle Area

Wed, 09 Sep 2015 12:35:06 +0000

计算两个矩形的面积和，有可能有重叠区域。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
 int bx,by,tx,ty;
 bx = A > E ? A : E;
 by = B > F ? B : F;
 tx = C < G ? C : G;
 ty = D < H ? D : H;

 int same = 0;
 if (tx <= bx || ty <= by) {
 same = 0;
 } else {
 same = (tx - bx) * (ty - by);
 }

 return (C - A) * (D - B) + (G - E) * (H - F) - same;
 }
};

[leetcode_198]House Robber

Mon, 07 Sep 2015 15:19:40 +0000

取出数组[正整数]中的数，使和最大，但是规则是不能去相邻的数。
可以枚举2^n中情况，复杂度太高。可以用一维动态规划的解法 f(n) = max(f(n-1), nums[n] + f(n-2));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 int rob(vector<int>& nums) {
 if (nums.size() <= 0)
 {
 return 0;
 }
 vector<int> v(nums.size() + 1);
 v[0] = 0;
 v[1] = nums[0];
 for (int i = 1; i < nums.size(); i++)
 {
 int j = i + 1;
 if (nums[i] + v[j - 2] > v[j - 1])
 {
 v[j] = nums[i] + v[j-2];
 }
 else
 {
 v[j] = v[j-1];
 }
 }
 return v[nums.size()];
 }
};

[leetcode_199]Binary Tree Right Side View

Mon, 07 Sep 2015 04:58:23 +0000

求二叉树中，每层最右边的节点的值，序列化每层二叉树，然后输出每层最后一个节点即可。

class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
vector<int> ans(0);
if (NULL == root)
{
return ans;
}
queue<TreeNode *> qList;
qList.push(root);
while (qList.size() > 0)
{
int size = qList.size();
for (int i = 0;i < size;i++)
{
TreeNode * head = qList.front();
if (NULL != head->left)
{
qList.push(head->left);
}
if (NULL != head->right)
{
qList.push(head->right);
}
qList.pop();
if (i == size-1)
{
ans.push_back(head->val);
}
}
}
return ans;
}
};

[leetcode_260]Single Number III

Mon, 07 Sep 2015 04:57:15 +0000

给定数组中，所有数都是成对出现，但是只有两个数，不成对，求出这两个数。
相信一个数的情况大家都知道，使用异或即可解决问题，两个数的话，异或了之后得到的是a^b，但是如何找出a与b呢，从a^b可以得，该值一定不为0，只需要取任何一个位数上不为0的数，将数组分为两类，在异或即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 vector<int> singleNumber(vector<int>& nums) {
 int ab = 0;
 for (int i = 0; i < nums.size(); i++) {
 ab ^= nums[i];
 }

 int pos = 0;
 while(0 == ab % 2) {
 pos++;
 ab /= 2;
 }

 int a = 0;
 int b = 0;
 int tmp = (int)pow(2.0, pos);

 for (int i = 0; i < nums.size(); i++) {
 if ((nums[i]^tmp) == (nums[i] - tmp)) {
 a ^= nums[i];
 }
 else {
 b ^= nums[i];
 }
 }

 vector<int> ans(0);
 ans.push_back(a);
 ans.push_back(b);
 return ans;
 }
};

[leetcode_206]Reverse Linked List

Tue, 01 Sep 2015 14:53:34 +0000

反转单链表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 ListNode* reverseList(ListNode* head) {
 if (NULL == head)
 {
 return head;
 }
 ListNode * before = NULL;
 ListNode * now = head;
 ListNode * next = now->next;

 while (NULL != next)
 {
 ListNode * beforeTmp = now;
 ListNode * nowTmp = next;
 ListNode * nextTmp = next->next;

 now->next = before;
 next->next = now;

 before = beforeTmp;
 now = nowTmp;
 next = nextTmp;
 }

 head = now;
 return head;
}
};

[leetcode_238] Product of Array Except Self

Mon, 31 Aug 2015 11:47:19 +0000

输入数组a1,a2,a3…

生成数组a2*a3, a1*a3, a1*a2，但是希望能够在O(n)的时间内解决，且不能使用除法。

用两个额外的数组记录ai前和ai后的乘积即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class Solution {
public:
 vector<int> productExceptSelf(vector<int>& nums) {
 int size = nums.size();
 vector<int> front(size), back(size), result(size);
 front[0] = 1;
 back[size-1] = 1;
 for (int i = 1;i < size;i++)
 {
 front[i] = front[i-1] * nums[i-1];
 }
 for (int i = size - 2;i >= 0;i--)
 {
 back[i] = back[i + 1] * nums[i + 1];
 }
 result[0] = back[0];
 result[size-1] = front[size - 1];
 for (int i = 1;i < size - 1;i++)
 {
 result[i] = front[i] * back[i];
 }
 return result;
 }
};

[leetcode_172]Factorial Trailing Zeroes

Mon, 31 Aug 2015 11:43:47 +0000

计算n!的尾部有多少个连续的0，实际上问题可以准换为，分解质因数后，有多少个5(因为2比5多)。但是计算机5的时候有技巧，如果直接每个数模的话会超时，实际上只需要计算5^k次与n的关系即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 int trailingZeroes(int n) {
 vector<int> five(14);
 for (int i = 1; i <= 13; i++) {
 five[i] = ((int)pow(5.0, i));
 }
 int before = 0;
 int count = 0;
 for (int i = 13; i >= 1; i--) {
 if (five[i] <= n) {
 count += (n / five[i] - before) * i;
 before = (n / five[i]);
 }
 }
 return count;
 }
};

[leetcode_257]Binary Tree Paths

Fri, 28 Aug 2015 14:24:23 +0000

遍历二叉树的所有路径，搜索即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 string convertIntToStr(int num)
 {
 char str[255];
 sprintf(str, "%d", num);
 return str;
 }

void binaryTreePath(TreeNode* node, string& path, vector<string>& paths)
{
 if (NULL == node)
 {
 return;
 }
 path += convertIntToStr(node->val);
 if (NULL != node->left)
 {
 string tmp = path;
 path += "->";
 binaryTreePath(node->left, path, paths);
 path = tmp;
 }
 if (NULL != node->right)
 {
 string tmp = path;
 path += "->";
 binaryTreePath(node->right, path, paths);
 path = tmp;
 }
 if (NULL == node->left && NULL == node->right)
 {
 paths.push_back(path);
 }
}

vector<string> binaryTreePaths(TreeNode* root) {
 vector<string> paths;
 paths.clear();

 string path = "";
 binaryTreePath(root, path, paths);

 return paths;
}
};

[leetcode_165] Compare Version Numbers

Thu, 27 Aug 2015 13:37:59 +0000

题意的换一种说法：
将输入的两个数字，分别用 . 分割，然后逐一比较大小。如果数字数量不一样，多的大。前提是多出来的有不为 0 的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


class Solution {
public:
 void getNums(string version1, vector<int> &v1)
 {
 int s = 0;
 int pos = version1.find(".");
 while (-1 != pos)
 {
 v1.push_back(atoi(version1.substr(s, pos - s).c_str()));
 s = pos + 1;
 pos = version1.find(".", pos + 1);
 }
 v1.push_back(atoi(version1.substr(s).c_str()));
 }
 int compareVersion(string version1, string version2) {
 vector<int> v1, v2;
 v1.clear();
 v2.clear();
 getNums(version1, v1);
 getNums(version2, v2);
 int min = v1.size() > v2.size() ? v2.size() : v1.size();
 for (int i = 0; i < min;i++)
 {
 if (v1[i] > v2[i])
 {
 return 1;
 }
 if (v1[i] < v2[i])
 {
 return -1;
 }
 }
 if (v1.size() > v2.size())
 {
 for (int i = min; i < v1.size(); i++)
 {
 if (v1[i] > 0)
 {
 return 1;
 }
 }
 return 0;
 }
 if (v1.size() < v2.size())
 {
 for (int i = min; i < v2.size(); i++)
 {
 if (v2[i] > 0)
 {
 return -1;
 }
 }
 return 0;
 }
 return 0;
 }
};

[leetcode_203]Remove Linked List Elements

Thu, 27 Aug 2015 13:32:41 +0000

删除单链表中指定的val的所有节点。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


class Solution {
public:
 ListNode* removeElements(ListNode* head, int val) {
 if (NULL == head)
 {
 return NULL;
 }
 ListNode * before = NULL;
 ListNode * now = head;
 while (now != NULL)
 {
 if (now -> val == val)
 {
 if (before == NULL)
 {
 head = head->next;
 now = head;
 }
 else
 {
 if (now != NULL)
 {
 before->next = now->next;
 }
 now = before->next;
 }
 }
 else
 {
 before = now;
 now = now->next;
 }
 }
 return head;
 }
};

[leetcode_268] Missing Number

Thu, 27 Aug 2015 13:30:51 +0000

给定数列中，从 0 到 n，但是缺少一个数字 i。求 i 为多少。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 int missingNumber(vector<int>& nums) {
 int sum = 0;
 int max = 0;
 bool isZero = false;
 for (int i = 0; i < nums.size(); i++) {
 sum += nums[i];
 if (nums[i] >= max) {
 max = nums[i];
 }
 if (nums[i] == 0) {
 isZero = true;
 }
 }
 int oSum = (0 + max) * (max - 0 + 1) / 2;
 if (oSum == sum) {
 if (!isZero) {
 return 0;
 } else {
 return max + 1;
 }
 } else {
 return oSum - sum;
 }
 }
};

[leetcode_160]Intersection of Two Linked Lists

Thu, 27 Aug 2015 13:28:46 +0000

判断两个单链表的重合节点。思路很简单，长度那个链表，先走差距步即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


class Solution {
public:
 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
 int countA = 0;
 int countB = 0;
 ListNode * tmpA = headA;
 ListNode * tmpB = headB;
 while(NULL != tmpA)
 {
 countA++;
 tmpA = tmpA->next;
 }
 while(NULL != tmpB)
 {
 countB++;
 tmpB = tmpB->next;
 }
 int move = 0;
 if (countA > countB)
 {
 while (move < countA - countB)
 {
 headA = headA->next;
 move++;
 }
 }
 else
 {
 while (move < countB - countA)
 {
 headB = headB->next;
 move++;
 }
 }
 while (headA != headB)
 {
 headA = headA->next;
 headB = headB->next;
 }
 return headA;
 }
};

[leetcode_173]Binary Search Tree Iterator

Thu, 27 Aug 2015 13:27:01 +0000

二叉搜索树的遍历，其实也就是树的中序遍历。可以用迭代的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


class BSTIterator {
public:
 int pos;
 vector<TreeNode *> treeNodeStack;

 void buildStack(TreeNode *node)
 {
 if (node == NULL)
 {
 return;
 }
 else
 {
 if (NULL != node->left)
 {
 buildStack(node->left);
 }
 treeNodeStack.push_back(node);
 if (NULL != node->right)
 {
 buildStack(node->right);
 }
 }
 }

 BSTIterator(TreeNode *root) {
 pos = 0;
 treeNodeStack.clear();
 buildStack(root);
 }

 /** @return whether we have a next smallest number */
 bool hasNext() {
 return treeNodeStack.size() > pos;
 }

 /** @return the next smallest number */
 int next() {
 return treeNodeStack[pos++]->val;
 }

};

[leetcode_204]Count Primes

Thu, 27 Aug 2015 13:25:23 +0000

统计小于输入数字n的所有素数的个数，用筛法即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 int * flag;
 int countPrimes(int n) {
 flag = new int[n + 10];
 for (int i = 1;i < n;i++)
 {
 flag[i] = 0;
 }
 for (int i = 2;i < n;i++)
 {
 if (0 == flag[i])
 {
 flag[i] = 1;
 for (int j = 2;j * i < n; j++)
 {
 flag[j * i] = -1;
 }
 }
 }
 int count = 0;
 for (int i = 1;i < n; i++)
 {
 if (1 == flag[i])
 {
 count++;
 }
 }
 return count;
 }
};

[leetcode_189]Rotate Array

Thu, 27 Aug 2015 13:24:07 +0000

根据输入k，对数组进行旋转，需要注意的是k的值可能是负数或者大于数组长度，模一下就好了。然后输出偏移量为size-k的两倍数组即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 void rotate(vector<int>& nums, int k) {
 if (nums.size() <= 0)
 {
 return ;
 }
 k %= nums.size();
 vector<int> dNums(nums.size() * 2);
 for (int i = 0;i < nums.size() * 2; i++)
 {
 dNums[i] = nums[i % nums.size()];
 }
 for (int i = 0;i < nums.size(); i++)
 {
 nums[i] = dNums[i + nums.size() - k];
 }
 }
};

[leetcode_168]Excel Sheet Column Title

Thu, 27 Aug 2015 13:22:04 +0000

将数字转换成Excel列好，开始以为简单的26进制，但是需要考虑到的是，进制中没有0，所以额外借用@来代表0，所以之后需要转换一次。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


class Solution {
public:
 string convertToTitle(int n) {
 string title = "";
 while (n > 0)
 {
 title += 'A' + n % 26 - 1;
 n /= 26;
 }
 int pos0 = 0;
 while (pos0 < title.length())
 {
 int pos = pos0;
 while (title[pos] == '@' && pos < title.length())
 {
 title[pos] = 'Z';
 if (pos + 1 < title.length() && title[pos + 1] != '@')
 {
 title[pos+1]--;
 pos++;
 }
 else
 {
 title = title.substr(0, pos);
 break;
 }
 }
 pos0++;
 }
 int s = 0;
 int e = title.length() - 1;
 while (s < e)
 {
 char tmp = title[s];
 title[s] = title[e];
 title[e] = tmp;
 s++;
 e--;
 }
 return title;
 }
};

[leetcode_228] Summary Ranges

Thu, 27 Aug 2015 13:17:31 +0000

简单的模拟题，合并区间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


class Solution {
public:
 string convertIntToStr(int num)
 {
 char str[255];
 sprintf(str, "%d", num);
 return str;
 }

 vector<string> summaryRanges(vector<int>& nums) {
 vector<string> ranges;
 ranges.clear();
 if (nums.size() <= 0)
 {
 return ranges;
 }
 int start = nums[0];
 int end = nums[0];
 for (int i = 1;i < nums.size(); i++)
 {
 if (nums[i] - nums[i-1] == 1)
 {
 end = nums[i];
 }
 else
 {
 string item = convertIntToStr(start);
 if (end == start)
 {
 ranges.push_back(item);
 }
 else
 {
 item += "-";
 item += convertIntToStr(end);
 ranges.push_back(item);
 }
 start = nums[i];
 end = start;
 }
 }
 string item = convertIntToStr(start);
 if (end == start)
 {
 ranges.push_back(item);
 }
 else
 {
 item += "-";
 item += convertIntToStr(end);
 ranges.push_back(item);
 }
 return ranges;
 }
};

[leetcode_190]Reverse Bits

Fri, 21 Aug 2015 14:19:09 +0000

将一个正整数，转换成二进制，然后颠倒顺序，再输出成十进制。模拟题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 uint32_t reverseBits(uint32_t n) {
 //To binary
 vector<int> nums(32, 0);
 int index = 0;
 while(n > 0)
 {
 nums[index++] = n % 2;
 n /= 2;
 }

 uint32_t ans = 0;
 for (int i = 0; i < nums.size(); i++)
 {
 ans += nums[i] * (uint32_t)pow(2.0, (int)(nums.size() - i - 1));
 }
 return ans;
 }
};

[leetcode_202]Happy Number

Fri, 21 Aug 2015 14:17:58 +0000

判断一个数 n 是否是 happy number。happy number 的定义是，各位数依次平方求和，看是否能等于 1，如果不等于 1，再重复上述过程。实际上，这个过程将会是一个循环。[猜的，并没有证明]。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 map<int, bool> flag;
 bool isHappy(int n)
 {
 if (n == 1)
 {
 return true;
 }
 map<int, bool>::iterator it = flag.find(n);
 if (it != flag.end())
 {
 return false;
 }
 else
 {
 flag.insert(map<int, bool>::value_type(n, true));
 }
 int tmpNum = 0;
 while (n > 0)
 {
 tmpNum += (n % 10) * (n % 10);
 n /= 10;
 }
 return isHappy(tmpNum);
 }
};

[leetcode_231]Power of Two

Fri, 21 Aug 2015 14:16:13 +0000

判断一个数是否是2的幂。有的是位运算，移位即可。

class Solution {
public:
bool isPowerOfTwo(int n) {
if (n <= 0)
{
return false;
}
while(true)
{
if (n == 1) {
return true;
}
if (n % 2 != 0) {
return false;
}
n >>= 1;
}
}
};

[leetcode_263]Ugly Number

Fri, 21 Aug 2015 14:14:39 +0000

判断一个数是否是丑数，模拟解出来的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 bool isUgly(int num) {
 if (num <= 0)
 {
 return false;
 }
 while(true)
 {
 if(num%2 == 0)
 {
 num /= 2;
 }
 else if(num%3 == 0)
 {
 num /= 3;
 }
 else if(num%5 == 0)
 {
 num /= 5;
 }
 else
 {
 if (num == 1)
 {
 return true;
 }
 else
 {
 return false;
 }
 }
 }
 }
};

[leetcode_225]Implement Stack using Queues

Fri, 21 Aug 2015 14:13:33 +0000

模拟一个栈，用vector偷懒解决问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Stack {
public:
 vector<int> stack;
 // Push element x onto stack.
 void push(int x) {
 stack.push_back(x);
 }

 // Removes the element on top of the stack.
 void pop() {
 stack.pop_back();
 }

 // Get the top element.
 int top() {
 return stack[stack.size() - 1];
 }

 // Return whether the stack is empty.
 bool empty() {
 return stack.empty();
 }
};

[leetcode_153]Find Minimum in Rotated Sorted Array

Fri, 21 Aug 2015 14:12:27 +0000

这个题挺有意思的，给定一个排序的数组：1,2,3,4,5,6,7，但是这个数组经过了一个旋转，比如，4,5,6,7,1,2,3。这个时候求这个数组中最小的元素。O(n)一定能解出来。记得去年面试滴滴打车的时候问过类似的问题。当时笃定是二分查找，但是感觉说得不清楚。这次做题显然思路就清晰了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 void binarySearch(vector<int>& nums, int left, int right, int &min)
 {
 if (left > right)
 {
 return ;
 }
 int mid = (left + right) / 2;
 if (nums[mid] >= min)
 {
 binarySearch(nums, left, mid - 1, min);
 binarySearch(nums, mid+1, right, min);
 }
 else
 {
 min = nums[mid];
 binarySearch(nums, left, mid - 1, min);
 }
 }

 int findMin(vector<int>& nums) {
 int min = nums[0];
 binarySearch(nums, 0, nums.size() - 1, min);
 return min;
 }
};

[leetcode_242]Valid Anagram

Fri, 21 Aug 2015 14:08:11 +0000

判断两个字符串是否含有相同的字母且字母个数相同。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Solution {
public:
 bool isAnagram(string s, string t) {
 vector&lt;int&gt; sCount(26, 0);
 for (int i = 0;i &lt; s.length();i++)
 {
 sCount[s[i] - 'a']++;
 }
 for (int i = 0;i &lt; t.length();i++)
 {
 sCount[t[i] - 'a']--;
 }
 for (int i = 0;i &lt; sCount.size(); i++)
 {
 if (0 != sCount[i])
 {
 return false;
 }
 }
 return true;
 }
};

[leetcode_169]Majority Element

Wed, 19 Aug 2015 13:03:04 +0000

求出给定数组中，超过半数的元素（保证有数字超过半数）。注意数组长度的奇偶。hash记录一下即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 int majorityElement(vector<int>& nums) {
 map<int, int> m_nums;
 m_nums.clear();
 for (int i = 0; i < nums.size(); i++)
 {
 auto it = m_nums.find(nums[i]);
 if (it == m_nums.end())
 {
 m_nums.insert({nums[i], 1});
 }
 else
 {
 m_nums.erase(nums[i]);
 m_nums.insert({nums[i], ++(it->second)});
 }
 }

 for (auto it = m_nums.begin(); it != m_nums.end(); it++)
 {
 if (it->second >= nums.size() / 2 + 1)
 {
 return it->first;
 }
 }
 }
};

[leetcode_217]Contains Duplicate

Wed, 19 Aug 2015 13:01:16 +0000

判断给定数组中是否含有重复元素。hash表即可解。实际上我用的是map，即C++中的二叉搜索树。O(logn)的解法，时间不是特别好。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 bool containsDuplicate(vector<int>& nums) {
 map<int, bool> m_nums;
 m_nums.clear();
 for (int i = 0; i < nums.size(); i++)
 {
 map<int, bool>::iterator it = m_nums.find(nums[i]);
 if (it == m_nums.end())
 {
 m_nums.insert(map<int, bool>::value_type(nums[i], true));
 }
 else
 {
 return true;
 }
 }
 return false;
 }
};

[leetcode_171]Excel Sheet Column Number

Wed, 19 Aug 2015 12:59:48 +0000

求Excel中AB表示的列的实际列数，其实就是二十六进制。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Solution {
public:
 int titleToNumber(string s) {
 int sum = 0;
 int size = s.length();
 for (int i = 0; i < size; i++) {
 sum += (s[i] - 'A' + 1) * (int)pow(26.0, (size - i - 1));
 }
 return sum;
 }
};

[leetcode_226]Invert Binary Tree

Wed, 19 Aug 2015 12:58:35 +0000

镜像二叉树，其实就是对二叉树的后序遍历+交换左右子节点。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 void swap(TreeNode & left, TreeNode *& right)
 {
 TreeNode * tmp = left;
 left = right;
 right = tmp;
 }
 TreeNode * invertTree(TreeNode* root) {
 if (root == NULL)
 return NULL;
 if (root->left != NULL)
 invertTree(root->left);
 if (root->right != NULL)
 invertTree(root->right);
 swap(root->left, root->right);
 return root;
 }
};

[leetcode_235]Lowest Common Ancestor of a Binary Search Tree

Wed, 19 Aug 2015 12:57:17 +0000

求二叉树中两个节点的最邻近公共祖先。以前做过类似的题目，但是确实好久没A题了，自己想了下。深度优先搜索，然后分别求出两条路径再求交，开始担心会超时，结果AC挺快的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Solution {
public:
 bool isFind;
 vector<TreeNode *> pV, qV;
 void FindK(TreeNode *node, TreeNode* k, vector<TreeNode *> &kV)
 {
 kV.push_back(node);
 if (isFind || node == k)
 {
 isFind = true;
 return;
 }
 if (NULL != node->left)
 {
 FindK(node->left, k, kV);
 if (isFind)
 {
 return;
 }
 kV.pop_back();
 }
 if (NULL != node->right)
 {
 FindK(node->right, k, kV);
 if (isFind)
 {
 return;
 }
 kV.pop_back();
 }
 }
 TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
 if (NULL == root)
 {
 return root;
 }
 pV.clear();
 qV.clear();
 isFind = false;
 FindK(root, p, pV);
 isFind = false;
 FindK(root, q, qV);
 int i = 0;
 int minSize = pV.size() > qV.size() ? qV.size() : qV.size();
 for (i = 0;i < minSize; i++)
 {
 if (pV[i] != qV[i])
 {
 break;
 }
 }
 return pV[i - 1];
 }
};

[leetcode_191]Number of 1 Bits

Wed, 19 Aug 2015 12:55:17 +0000

请输入整数的二进制中1的个数，简单的模拟。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Solution {
public:
 int hammingWeight(uint32_t n) {
 int count = 0;
 while(n > 0)
 {
 count += n%2;
 n /= 2;
 }
 return count;
 }
};

[leetcode_237]Delete Node in a Linked List

Wed, 19 Aug 2015 12:53:27 +0000

删除单链表中，指定的节点。
最开始读题的时候，觉得至少应该给头节点和目标节点，但是猜测之后发现，题目可能是要求，将目标节点后的节点的val覆盖前面的节点的val，而不是单链表中真正意义的删除。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 void deleteNode(ListNode* node) {
 ListNode * next = node->next;
 ListNode * before = NULL;
 while(next != NULL)
 {
 node->val = next->val;
 before = node;
 node = next;
 next = next->next;
 }
 before->next = NULL;
 }
};

[leetcode_258]Add Digits

Wed, 19 Aug 2015 12:38:32 +0000

O(1)的方法没有想出来，模拟的方法如下：
每次计算所有位数之和，直到该和小于10。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 int addDigits(int num) {
 int sum = 0;
 while(num > 0)
 {
 sum += num % 10;
 num /= 10;
 }
 if (sum >= 10)
 {
 return addDigits(sum);
 }
 else
 {
 return sum;
 }
 }
};

[C++] 绘制菱形

Mon, 27 Jul 2015 02:04:30 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <iostream>
using namespace std;

int main()
{
 int n; // 菱形最长行的个数为n，且n一定为奇数因为 n = 2*k + 1
 cin >> n;

 int cn = 1;
 bool isUp = true;
 for (int i = 1; i <= n; i++) {
 for (int j = 1; j <= (n - cn) / 2; j++) {
 cout << " ";
 }
 for (int j = 1; j <= cn; j++) {
 cout << "*";
 }
 for (int j = 1; j <= (n - cn) / 2; j++) {
 cout << " ";
 }
 cout << endl;

 if (cn >= n) {
 isUp = false;
 }
 if (isUp) {
 cn += 2;
 } else {
 cn -= 2;
 }
 }
 return 0;
}

[C++]c++创建txt文件，文件名为输入的字符串，求字节数

Sun, 26 Jul 2015 02:04:30 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>
using namespace std;

int main() {
 char filename[255];
 cin >> filename;

 FILE * pFile = fopen(filename, "r");
 fseek(pFile, 0L, SEEK_END);
 long count = ftell(pFile);
 cout << "字节数=" << count << endl;
 fclose(pFile);
 return 0;
}

[编程之美_2.9]斐波那契数列

Sat, 23 May 2015 05:20:58 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


int Fibonacci(int n)
{
 if (1 == n)
 {
 return 1;
 }
 if (2 == n)
 {
 return 2;
 }
 return Fibonacci(n-1) + Fibonacci(n-2);
}

int FibonacciIteration (int n)
{
 int a = 1;
 int b = 2;
 if (n == 1)
 return a;
 if (n == 2)
 return b;
 for (int i = 3; i <= n; i++)
 {
 int now = a + b;
 a = b;
 b = now;
 }
 return b;
}

书中提到了一种方法： fi = fi-1 + fi-2 =>转换成矩阵的形式

[编程之美_2.9]斐波那契数列
时间复杂度为：O(log2n)。

[编程之美_2.8]找符合条件的整数

Sat, 23 May 2015 05:19:47 +0000

题意很简单，给定一个n, 求一个最小的m，使得n_m中的10进制表示只有0,1
方法1：Brute Force [大整数的情况需要考虑，何时终止，时间复杂度如何？]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


bool CheckNumber(int number)
{
 while(number)
 {
 if (number%10 != 0 && number%10 != 1)
 return false;
 number /= 10;
 }
 return true;
}

int CalcMBruteForce(int n)
{
 int m = 1;
 while (!CheckNumber(m * n))
 {
 m++;
 }
 return m;
}

方法2：BFS [大整数的情况需要考虑，何时终止，去重复计算问题]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


int CalcM(int number)
{
 int i = 1;
 vector<int> vList;
 vList.clear();
 vList.push_back(0);
 vList.push_back(1);
 vector<int> vListC;
 int k = 1;
 // TODO:
 // BigInt
 // Delete duplicate
 while (true)
 {
 vListC.clear();
 for (vector<int>::size_type i = 0; i < vList.size(); i++)
 {
 if (vList[i] && vList[i] % number == 0)
 {
 return vList[i];
 }
 vListC.push_back(vList[i] + 0);
 vListC.push_back(vList[i] + (int)pow(10.0, k));
 }
 vList.clear();
 vList = vListC;
 k++;
 }
}

[编程之美_2.7]最大公约数的问题

Sat, 23 May 2015 05:18:46 +0000

GCD: 最大公约数，能被m,n整数整除的最大的整数。
貌似很早的就有了欧几里得的辗转相除法法
GCD(x, y) = GCD(x, x%y)
x = k*y + ｂ若d是x, y的最大公约数，那么d一定能被b整除，且d是x和b的最大公约数，b为x%y
代码如下：

1
2
3
4
5


// GCD
int GCD(int x, int y)
{
 return y == 0 ? x : GCD(y, x % y);
}

在《编程之美》书中有对时间上的优化：

取模运算含有除法，比较耗时
大整数下该如何优化

[编程之美_2.6]精确表达浮点数

Sat, 23 May 2015 05:17:49 +0000

以下代码将问题简化为求无限循环小数的分数，至于有限的直接改成分数即可，不过涉及到另一个重要知识，就是求最大公约数，比较经典的是辗转相除法。
代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// GCD
int GCD(int x, int y)
{
 return y == 0 ? x : GCD(y, x % y);
}

// Simplified conditions
// x: 无限循环小数
// n: 循环节的整数表示
// m: 循环节长度
// 10^m * x = n + x
// x = n / (10^m - 1)
void FloatNumber(string number)
{
 int start = number.find_first_of('(') + 1;
 int end = number.find_first_of(')');
 string repetend = number.substr(start, end - start);
 int n = atoi(repetend.c_str());
 int m = end - start;
 int d = GCD(n, ((int)pow(10.0, m) - 1));
 cout << n / d << '/' << ((int)pow(10.0, m) - 1) / d << endl;
}

[编程之美_2-5]寻找最大的k个数

Sat, 23 May 2015 05:16:43 +0000

这个问题与寻找第k大/小数等价。
方法1: 直接排序输出[编程之美书上说：不同的排序方法时间复杂度不一样，诚然，因为不需要n个数有序，只需要最大的k个数即可]
选用快速排序：

1
2
3
4
5
6


vector<int> FindMostKSort(vector<int>& vNumbers, int k)
{
 sort(vNumbers.begin(),vNumbers.end());
 vector<int> vKNumbers(vNumbers.rbegin(), vNumbers.rbegin() + k);
 return vKNumbers;
}

方法2: 实际上并不需要全部数有序，其实可以模拟快速排序的划分过程，求某个数排序之后在第k个位置即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


void swap(int &a, int &b)
{
 int tmp = a;
 a = b;
 b = tmp;
}
void FindMostKPartition(vector<int>& vNumber, int k, int left, int right)
{
 int index = left;
 int tmp = vNumber[index];
 int i = left;
 int j = right;
 while (i < j)
 {
 while(i < j && vNumber[j] >= vNumber[index]) j--;
 swap(vNumber[j], vNumber[index]);
 index = j;
 while(i < j && vNumber[i] <= vNumber[index]) i++;
 swap(vNumber[i], vNumber[index]);
 index = i;
 }
 if (index - left + 1 == k)
 {
 cout << vNumber[index] << endl;
 }
 else if (index - left + 1 < k)
 {
 FindMostKPartition(vNumber, k - (index - left + 1), index + 1, right);
 }
 else
 {
 FindMostKPartition(vNumber, k, left, index - 1);
 }
}

方法3: 堆排序[维护一个k数量的最小堆即可，STL代码如此短啊，不过可以自己用数组实现堆]

PS: 排序均用STL实现，具体的排序自己实现，将在近期尝试编写。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


void FindMostKHeap(vector<int>& vNumbers, int k)
{
 vector<int> vKNumbers(vNumbers.begin(), vNumbers.begin() + k);
 make_heap(vKNumbers.begin(), vKNumbers.end(), greater<int>());
 for (vector<int>::size_type i = k; i < vNumbers.size(); i++)
 {
 if (vNumbers[i] > vKNumbers[0])
 {
 vKNumbers[0] = vNumbers[i];
 make_heap(vKNumbers.begin(), vKNumbers.end(), greater<int>());
 }
 }
 cout << vKNumbers[0] << endl;
}

[编程之美_2.4]1的数目

Sat, 23 May 2015 05:15:31 +0000

题意很简单，给定一个正整数n，求1-n中，1出现在各个数中的位数的次数之和。
比如针对特定的数12312，global count += 2;因为出现了两个1，输入n，要统计1-n的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


int VerifyCountOneNumberAns(int n)
{
 int ans = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while(tmp)
 {
 if (1 == tmp%10) ans++;
 tmp /= 10;
 }
 }
 return ans;
}
int CountOneNumber(int n)
{
 if (n == 0)
 return 0;
 if (n < 10)
 return 1;
 vector<int> vNumber;
 vNumber.clear();
 int tmp = n;
 while(tmp)
 {
 vNumber.push_back(tmp%10);
 tmp /= 10;
 }
 int count = 0;
 int vSize = vNumber.size();
 count = (vSize - 1) * vNumber[vSize - 1] * (int)pow(10.0, (int)(vSize - 2));
 if (vNumber[vSize - 1] > 1)
 {
 count += (int)pow(10.0, (int)(vSize - 1));
 }
 else
 {
 count += n - vNumber[vSize - 1] * (int)pow(10.0, vSize - 1) + 1;
 }
 count += CountOneNumber(n - vNumber[vSize - 1] * (int)pow(10.0, vSize - 1));
 return count;
}
int main()
{
 vector<int> ids;
 for (int i = 1; i <= 10000; i++)
 {
 int count = CountOneNumber(i);
 int ans = VerifyCountOneNumberAns(i);
 if (ans != count)
 cout << i << '\t' << ans << '\t' << count << endl;
 }
 return 0;
}

代码中有验证程序，验证程序的正确性是不用怀疑的，然后题目给出了一种递归的方法，时间上还可以接受，应该和数的位数成正比。
PS：自己果然不擅长数学，做起来挺吃力的。不过逻辑还挺好使的。。

[编程之美_2.3]寻找发帖“水王”

Sat, 23 May 2015 05:14:27 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


int FindMostIds(vector<int> &ids)
{
 map<int,int> hashIds;
 map<int,int>::iterator it;
 hashIds.clear();
 for (int i = 0; i < ids.size(); i++)
 {
 it = hashIds.find(ids[i]);
 if (hashIds.end() == it)
 {
 hashIds.insert(map<int,int>::value_type(ids[i],1));
 }
 else
 {
 it->second++;
 }
 }
 int id = 0, count = -1;
 for (it = hashIds.begin(); it != hashIds.end(); it++)
 {
 if (it->second > count)
 {
 id = it->first;
 count = it->second;
 }
 }
 return id;
}

这个题1：可以继续优化；2：如果是出现3个发帖水王，每个人超过四分之一的帖子，该题如何解？今天晚了，先回宿舍，明日再解，其实我已经想到方法了。
问题1：
编程之美的书上说，可以在空间复杂度上优化到O(1)
看书之后得到提示：
用一个id来存当前id
count来存id的计数，然后比较是否相等，动态维护，最终的id一定是水王。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


int FindMostIds(vector<int> &ids)
{
 if (ids.size() <= 0)
 return -1;
 int id = ids[0];
 int count = 1;
 for (vector<int>::size_type i = 1; i < ids.size(); i++)
 {
 if (0 == count)
 {
 id = ids[i];
 count = 1;
 continue;
 }
 if (id == ids[i])
 {
 count++;
 }
 else
 {
 count--;
 }
 }
 return id;
}

问题2：可以用问题1解法2的推广：[自己想的，没有经过严格测试，目测思想正确]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


void FindMostIds(vector<int> &ids)
{
 if (ids.size() <= 0)
 return ;
 int id[3] = {-1, -1, -1};
 int count[3] = {0, 0, 0};
 for (vector<int>::size_type i = 1; i < ids.size(); i++)
 {
 bool flag = false;
 for (int j = 0; j < 3; j++)
 {
 if (id[j] == ids[i])
 {
 count[j]++;
 flag = true;
 break;
 }
 }
 if (flag) continue;

 flag = false;
 for (int j = 0; j < 3; j++)
 {
 if (count[j] == 0)
 {
 id[j] = ids[i];
 count[j]++;
 flag = true;
 break;
 }
 }
 if (flag) continue;
 for (int j = 0; j < 3; j++)
 {
 count[j]--;
 }
 }
 for (int i = 0; i < 3; i++)
 {
 cout << id[i] << '\t';
 }
 cout << endl;
}

[编程之美_2.2]不要被阶乘吓到

Sat, 23 May 2015 05:11:00 +0000

题意要求计算n!的value值后面有0的个数，实际上可以理解为n!的计算中有多少个5的倍数被乘入。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


int CountZero(int n)
{
 int cnt = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while (0 == i % 5)
 {
 cnt++;
 tmp /= 5;
 }
 }
 return cnt;
}

题意求N!中二进制表示最低位1的位置，可以发现奇数的乘入对1的位置没有影响。一旦乘以2，整个数值为左移1位，故最后结果和分解因数后2的个数有关

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


int CountBinaryOne(int n)
{
 int cnt = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while (0 == tmp % 2)
 {
 cnt++;
 tmp /= 2;
 }
 }
 return cnt;
}

[编程之美_2.1]求二进制中1的个数

Sat, 23 May 2015 05:09:14 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int CountOne(int val)
{
 int cnt = 0;
 while (val)
 {
 val &= val - 1;
 cnt++;
 }
 return cnt;
}

[编程之美_1]CPU绘制曲线

Sat, 23 May 2015 05:06:15 +0000

其实这个题满跑很简单，那就是写个死循环就行了。操作系统分给的时间片就会越来越多。但是现在的程序都是多核的，比如我的电脑是4核的，会发现，CPU大概永远在25~27%左右，并没有达到100%。

如果想达到百分之百，只需要使用多线程，就可以了。

今天看到最挑衅的一句话是：

有种你让CPU画个圆，当时整个人都不好了。。。

下面来看50%的情况，编程之美上说，“sleep一个时间片，work一个时间片”不停切换应该就可以到50%。后来我发现效果不好。就算使用GetTickCount，效果也不好，因为毕竟电脑还有别的程序要运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


void Work(DWORD time)
{
 DWORD now = GetTickCount();
 for(;GetTickCount() <<- endstream>> now + time;)
 {
 }
}
DWORD WINAPI DrawThread(LPVOID lParam)
{
 double deta = 0.1f;
 while (true)
 {
 double time = 500 + 500 * sin(deta);
 Work(time);
 Sleep(1000-time);
 deta += 0.1f;
 }
 return 0;
}
int main()
{
 HANDLE hThread[4];
 DWORD idThread[4];
 hThread[0] = CreateThread(0,0,DrawThread,NULL,0,& idThread[0]);
 hThread[1] = CreateThread(0,0,DrawThread,NULL,0,& idThread[1]);
 hThread[2] = CreateThread(0,0,DrawThread,NULL,0,& idThread[2]);
 hThread[3] = CreateThread(0,0,DrawThread,NULL,0,& idThread[3]);
 SetThreadAffinityMask(hThread[0], 0x00000001);
 SetThreadAffinityMask(hThread[1], 0x00000010);
 SetThreadAffinityMask(hThread[2], 0x00000100);
 SetThreadAffinityMask(hThread[3], 0x00001000);

 WaitForSingleObject(hThread[0], INFINITE);
 WaitForSingleObject(hThread[1], INFINITE);
 WaitForSingleObject(hThread[2], INFINITE);
 WaitForSingleObject(hThread[3], INFINITE);

 return 0;
}

[leetcode_151]Reverse Words in a String

Sat, 23 May 2015 03:22:13 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution
{
public:
 int getFirstLetter(string &s,int start)
 {
 int i;
 for(i = start;i < s.length();i++)
 {
 if(s[i] != ' ')return i;
 }
 return i;
 }
 int getFirstBlank(string &s,int start)
 {
 int i;
 for(i = start;i < s.length();i++)
 {
 if(s[i] == ' ')return i;
 }
 return i;
 }
 void reverseWords(string &s) {
 vector<string> splits;
 splits.clear();
 int i = 0;
 while(i < s.length())
 {
 i = getFirstLetter(s,i);
 if(i >= s.length())break;
 int next = getFirstBlank(s,i+1);
 if(next >= s.length())
 {
 next = s.length()-1;
 splits.push_back(s.substr(i,next-i+1));
 break;
 }
 splits.push_back(s.substr(i,next-i));
 i = next;
 }
 s = "";
 for(int i = splits.size()-1;i >= 0;i--)
 {
 s += splits[i];
 if(i != 0)s += " ";
 }
 }
};

[leetcode]发张截图纪念一下

Sat, 23 May 2015 03:21:17 +0000

[leetcode_68]Text Justification

Sat, 23 May 2015 03:20:29 +0000

好激动！！！leetcode终于全部AC一次了，虽然经历过波折，还是很兴奋啊！！！
大模拟，就是将字符串按规定句式输出。leetcode的好处就是很看到测试数据，好好理解题意，慢慢调试吧，一次AC其实应该蛮难的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89


class Solution {
public:
 vector<string> fullJustify(vector<string> &words, int L) {
 vector<vector<string>> result;
 result.clear();
 vector<string> ans;
 ans.clear();
 if (L == 0) {
 ans.push_back("");
 return ans;
 }
 for (int i = 0; i < words.size(); i++) {
 vector<string> item;
 item.clear();
 int sum = 0;
 while (true) {
 if (item.size() > 0) sum += 1;
 if (sum >= L) {
 i--;
 break;
 }
 if (i >= words.size()) break;
 item.push_back(words[i]);
 sum += words[i].length();
 if (sum > L) {
 item.pop_back();
 i--;
 break;
 }
 i++;
 }
 result.push_back(item);
 }
 for (int i = 0; i < result.size(); i++) {
 string item = "";
 if (i != result.size() - 1) item = genString(result[i], L);
 else
 item = genStringLast(result[i], L);
 ans.push_back(item);
 }
 return ans;
 }
private:
 string genStringLast(vector<string> &item, int L) {
 int sum = 0;
 string str = "";
 for (int i = 0; i < item.size(); i++) {
 str += item[i];
 sum += item[i].size();
 if (i != item.size() - 1) {
 str += " ";
 sum += 1;
 }
 }
 for (int i = 0; i < L - sum; i++)
 str += " ";
 return str;
 }
 string genString(vector<string> &item, int L) {
 int sum = 0;
 for (int i = 0; i < item.size(); i++)
 sum += item[i].size();
 string str = "";
 if (item.size() == 1) {
 int countS = L - sum;
 str += item[0];
 for (int j = 0; j < countS; j++)
 str += " ";
 return str;
 }
 int spaces;
 if (item.size() > 1) spaces = (L - sum) / (item.size() - 1);
 else
 spaces = 0;
 int ex = L - sum - spaces * (item.size() - 1);
 for (int i = 0; i < item.size(); i++) {
 str += item[i];
 int countS;
 if (i < ex)
 countS = 1 + spaces;
 else
 countS = spaces;
 if (i != item.size() - 1)
 for (int j = 0; j < countS; j++)
 str += " ";
 }
 return str;
 }
};

[leetcode_146]LRU Cache

Sat, 23 May 2015 03:19:36 +0000

双链表模拟队列，然后两个map存储key-value和key-_ListNode优化查找时间。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95


struct ListNodel {
 int key;
 ListNodel *before;
 ListNodel *next;
 ListNodel(int x) : key(x), before(NULL), next(NULL) {}
};

class LRUCache{
public:
 map<int, int> mapkv;
 map<int, ListNodel*> mapkl;
 int capacityq;
 ListNodel * head, *tail;

 LRUCache(int capacity) {
 capacityq = capacity;
 mapkv.clear();
 mapkl.clear();
 head = NULL;
 tail = NULL;
 }

 int get(int key) {
 map<int, int>::iterator it = mapkv.find(key);
 if (it != mapkv.end()) {
 update(key);
 return it->second;
 } else {
 return -1;
 }
 }

 void set(int key, int value) {
 map<int, int>::iterator it = mapkv.find(key);
 if (it != mapkv.end()) {
 it->second = value;
 update(key);
 } else {
 if (mapkv.size() < capacityq) {
 insertKeyValue(key, value);
 } else {
 ListNodel * tmp = head;
 head = head->next;
 mapkl.erase(tmp->key);
 mapkv.erase(tmp->key);
 delete(tmp);
 insertKeyValue(key, value);
 }
 }
 }

private:
 void insertKeyValue(int key, int value) {
 mapkv.insert(map<int, int>::value_type(key, value));
 if (head == NULL) {
 ListNodel * tmp = new ListNodel(key);
 mapkl.insert(map<int, ListNodel*>::value_type(key, tmp));
 head = tmp;
 tail = tmp;
 head->next = tail;
 tail->before = head;
 tail->next = NULL;
 } else {
 ListNodel * tmp = new ListNodel(key);
 mapkl.insert(map<int, ListNodel*>::value_type(key, tmp));
 tmp->before = tail;
 tail->next = tmp;
 tmp->next = NULL;
 tail = tmp;
 }
 }

 void update(int key) {
 map<int, ListNodel*>::iterator it = mapkl.find(key);
 ListNodel * tmp = it->second;
 if (tmp == head) {
 if (head->next != NULL) {
 head = head->next;
 tail->next = tmp;
 tmp->before = tail;
 tmp->next = NULL;
 tail = tmp;
 }
 } else if (tmp != tail) {
 ListNodel * tmpb = tmp->before;
 ListNodel * tmpn = tmp->next;
 tmpb->next = tmpn;
 tmpn->before = tmpb;
 tmp->before = tail;
 tail->next = tmp;
 tmp->next = NULL;
 tail = tmp;
 }
 }
};

[leetcode_44]Wildcard Matching

Sat, 23 May 2015 03:18:44 +0000

dfs一直超时，就算用了备忘录也超时。代码附上，纪念一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Solution {
public:
 bool isMatch(const char *s, const char *p) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 const char *tmp = p;
 int cnt = 0;
 while (*tmp != '\0') if (*(tmp++) != '*') cnt++;
 if (cnt > strlen(s)) return false;

 if(strlen(s) == 0) {
 for(int i = 0;i < strlen(p);i++) {
 if(p[i] != '*')return false;
 }
 return true;
 }

 int **dp;
 dp = new int*[strlen(s) + 1];
 for(int i = 0; i <= strlen(s); i++) {
 dp[i] = new int[strlen(p) + 1];
 }
 dp[0][0] = 1;
 int i = 0;
 while(p[i++] == '*') dp[0][i] = 1;
 for(int i = 1; i <= strlen(s); i++) {
 for(int j = 1; j <= strlen(p); j++) {
 if(dp[i-1][j-1] == 1 && (s[i-1] == p[j-1] || p[j-1] == '?')) {
 dp[i][j] = 1;
 }
 if(p[j-1] == '*' && (dp[i][j-1] == 1 || dp[i-1][j-1] == 1 || dp[i-1][j] == 1)) {
 dp[i][j] = 1;
 }
 }
 }
 if(dp[strlen(s)][strlen(p)] == 1) return true;
 else
 return false;
 }
};

[leetcode_130]Surrounded Regions

Sat, 23 May 2015 03:17:52 +0000

还是宽度优先搜索。从边界开始找O，没访问到的O就是被X包围起来的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


struct Pointp {
 int x;
 int y;
 Pointp() : x(0), y(0) {}
 Pointp(int a, int b) : x(a), y(b) {}
};
class Solution {
public:
 int lenm,lenn;
 int **map;
 void solve(vector<vector<char>> &board) {
 lenm = board.size();
 if(lenm <= 1)return ;
 lenn = board[0].size();
 map = new int *[lenm];
 for(int i = 0;i < lenm;i++) {
 map[i] = new int[lenn];
 }
 for(int i = 0;i < lenm;i++) {
 for(int j = 0;j < lenn;j++) {
 if(board[i][j] == 'O')map[i][j] = 0;
 else
 if(board[i][j] == 'X')map[i][j] = 1;
 }
 }
 for(int i = 0;i < lenm;i++) {
 for(int j = 0;j < lenn;j++) {
 if((i == 0 || j == 0 || i == lenm-1 || j == lenn-1)&&(map[i][j] == 0)) {
 map[i][j] = 2;
 bfs(i,j);
 }
 }
 }
 for(int i = 0;i < lenm;i++) {
 for(int j = 0;j < lenn;j++) {
 if(map[i][j] != 2)board[i][j] = 'X';
 }
 }
 //for(int i = 0;i < lenm;i++) {
 // for(int j = 0;j < lenn;j++) {
 // cout << board[i][j] << ' ';
 // }
 // cout << endl;
 //}
 }
private:
 void bfs(int x,int y) {
 int walk[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
 vector<Pointp>arr,arrs;
 arr.clear();
 arrs.clear();
 Pointp p(x,y);
 arr.push_back(p);
 while(true) {
 arrs.clear();
 for(int i = 0;i < arr.size();i++) {
 for(int j = 0;j < 4;j++) {
 int x = arr[i].x + walk[j][0];
 int y = arr[i].y + walk[j][1];
 if((x >= 0 && x <= lenm-1)&&(y >= 0 && y <= lenn-1)&&map[x][y] == 0) {
 map[x][y] = 2;
 arrs.push_back(Pointp(x,y));
 }
 }
 }
 if(arrs.size() == 0)break;
 arr.clear();
 for(int i = 0;i < arrs.size();i++) {
 arr.push_back(arrs[i]);
 }
 }
 }
};

[leetcode_140]Word Break II

Sat, 23 May 2015 03:16:58 +0000

依然是宽度优先搜索，这个题需要用dp判断下是否可解。我也是看别人的博客才知道，不然一直TLE。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


class Solution {
public:
 bool **map;
 set<int> wordlens;
 vector<string> result;
 vector<string> wordBreak(string s, unordered_set<string> &dict) {
 wordlens.clear();
 unordered_set<string>::iterator it;
 for(it = dict.begin(); it != dict.end(); it++) {
 string itstr = *it;
 wordlens.insert(itstr.length());
 }
 result.clear();
 map = new bool*[s.length()];
 for(int i = 0; i < s.length(); i++) {
 map[i] = new bool[s.length()];
 for(int j = 0; j < s.length(); j++) {
 map[i][j] = false;
 }
 }
 for(int start = 0; start < s.length(); start++) {
 for(int len = 1; len <= s.length() - start; len++) {
 string tmp = s.substr(start, len);
 if(dict.find(tmp) != dict.end()) {
 map[start][start + len - 1] = true;
 }
 }
 }
 for(int i = 0; i < s.length(); i++) {
 for(int j = 0; j <= i; j++) {
 for(int k = j; k < i; k++) {
 if(map[j][k] && map[k + 1][i]) map[j][i] = true;
 }
 }
 }
 // for(int i = 0; i < s.length(); i++) {
 // for(int j = 0; j < s.length(); j++) {
 // cout << map[i][j] << ' ';
 // }
 // cout << endl;
 // }
 if(map[0][s.length() - 1] == false) return result;
 string item = "";
 findSen(s, 0, dict, item);
 return result;
 }
private:
 void findSen(string &s, int start, unordered_set<string> &dict, string &item) {
 if(start >= s.length()) {
 result.push_back(item);
 return;
 }
 set<int>::iterator it;
 for(it = wordlens.begin(); it != wordlens.end(); it++) {
 int len = *it;
 if(start + len > s.length()) return;
 string tmp = string(s, start, len);
 if(dict.find(tmp) != dict.end()) {
 string itembp = item;
 if(start != 0) item += " ";
 item += tmp;
 findSen(s, start + len, dict, item);
 item = itembp;
 }
 }
 }
};

[leetcode_126]Word Ladder II

Sat, 23 May 2015 03:16:05 +0000

宽度优先搜索+存储路径。一直在做的就是优化时间。用map优化到1500ms好感动。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97


struct NodeString {
 vector<NodeString *> before;
 string now;
};
class Solution {
public:
 vector<vector<string>> result;
 vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 result.clear();
 if (dict.find(start) == dict.end()) {
 dict.insert(start);
 }
 if (dict.find(end) == dict.end()) {
 dict.insert(end);
 }
 map<string, NodeString *> maps;
 maps.clear();
 maps.insert(map<string, NodeString *>::value_type(start, NULL));
 vector<NodeString *> strs, strsc;
 strs.clear();
 NodeString *nodeString = new NodeString();
 nodeString->before.clear();
 nodeString->now = start;
 strs.push_back(nodeString);
 bool isFind = false;
 while (true) {
 map<string, NodeString *> mapstmp;
 mapstmp.clear();
 strsc.clear();
 for (int i = 0; i < strs.size(); i++) {
 string item = strs[i]->now;
 for (int j = 0; j < item.length(); j++) {
 for (char c = 'a'; c <= 'z'; c++) {
 string tmp = item;
 if (c != item[j]) {
 tmp[j] = c;
 if (dict.find(tmp) != dict.end()) {
 if (maps.find(tmp) == maps.end()) {
 NodeString *nodetmp = new NodeString();
 nodetmp->before.clear();
 nodetmp->before.push_back(strs[i]);
 nodetmp->now = tmp;
 if (tmp == end) {
 isFind = true;
 vector<string> items;
 items.clear();
 // items.push_back(end);
 genResult(nodetmp, items);
 continue;
 }
 strsc.push_back(nodetmp);
 maps.insert(map<string, NodeString *>::value_type(tmp, nodetmp));
 mapstmp.insert(map<string, NodeString *>::value_type(tmp, nodetmp));
 } else {
 if (tmp != start) {
 map<string, NodeString *>::iterator it = mapstmp.find(tmp);
 if (it != mapstmp.end())
 it->second->before.push_back(strs[i]);
 }
 }
 }
 }
 }
 }
 }

 if (strsc.size() == 0 || isFind) break;
 strs.clear();
 for (int i = 0; i < strsc.size(); i++) {
 strs.push_back(strsc[i]);
 }
 }
 return result;
 }

private:
 void genResult(NodeString *nodeString, vector<string> &items) {
 if (nodeString->before.size() == 0) {
 items.push_back(nodeString->now);
 vector<string> itemsr;
 itemsr.clear();
 vector<string>::reverse_iterator rit;
 for (rit = items.rbegin(); rit != items.rend(); rit++) {
 itemsr.push_back(*rit);
 }
 result.push_back(itemsr);
 items.pop_back();
 } else {
 for (int i = 0; i < nodeString->before.size(); i++) {
 items.push_back(nodeString->now);
 genResult(nodeString->before[i], items);
 items.pop_back();
 }
 }
 }
};

[leetcode_127]Word Ladder

Sat, 23 May 2015 03:15:01 +0000

图的最短路径T+T
看别人博客才知道的。之前一直傻傻地用BFS+map
各种超时啊。
后来也想到求出临近点了，就差一点点就可以到最短路径了。惭愧。
现附上超时的代码，明天再改最短路径。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


class Solution {
public:
 int ladderLength(string start, string end, unordered_set<string> &dict) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(dict.find(start) == dict.end()) {
 dict.insert(start);
 }
 if(dict.find(end) == dict.end()) {
 dict.insert(end);
 }
 map<string,bool> maps;
 maps.clear();
 maps.insert(map<string,bool>::value_type(start,true));
 vector<string> strs,strsc;
 strs.clear();
 strs.push_back(start);
 int count = 1;
 while(true) {
 strsc.clear();
 count++;
 for(int i = 0;i < strs.size();i++) {
 string item = strs[i];
 for(int j = 0;j < item.length();j++) {
 for(char c = 'a';c <= 'z';c++) {
 string tmp = item;
 if(c != item[j]) {
 tmp[j] = c;
 if(dict.find(tmp) != dict.end() && maps.find(tmp) == maps.end()) {
 strsc.push_back(tmp);
 if(tmp == end) return count;
 maps.insert(map<string,bool>::value_type(tmp,true));
 }
 }
 }
 }
 }
 if(strsc.size() == 0) break;
 strs.clear();
 for(int i = 0;i < strsc.size();i++) {
 strs.push_back(strsc[i]);
 }
 }
 return 0;
 }
};

[leetcode_76]Minimum Window Substring

Sat, 23 May 2015 03:14:00 +0000

双指针，第一个指针开始指向第一个字符，从前往后枚举第二个指针的位置，如果覆盖所有目标字符，则滑动首指针，看看是否依然满足条件。求出最小区间即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


class Solution {
public:
 int letters1[256];
 int letters2[256];
 string minWindow(string S, string T) {
 for(int k = 0;k < 256;k++) {
 letters1[k] = 0;
 letters2[k] = 0;
 }
 for(int k = 0;k < T.length();k++) {
 letters1[T[k]]++;
 letters2[T[k]]++;
 }
 int min = S.length()+T.length();
 int start,end;
 int count = T.length();
 int i = 0;
 for(int j = 0;j < S.length();j++) {
 if(letters2[S[j]] > 0) {
 letters1[S[j]]--;
 if(letters1[S[j]] >= 0)count--;
 }
 if(count == 0) {
 while(true) {
 if(letters2[S[i]] > 0) {
 if(letters1[S[i]] < 0)
 letters1[S[i]]++;
 else
 break;
 }
 i++;
 }
 if(j - i + 1 < min) {
 min = j - i + 1;
 start = i;
 end = j;
 }
 }
 }
 if(min == S.length()+T.length())return "";
 return string(S,start,end - start + 1);
 }
};

[leetcode_30]Substring with Concatenation of All Words

Sat, 23 May 2015 03:12:59 +0000

暴力bf过的。
使用map来查找当前定长的字符串是否是“需要”[需要找到]的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


class Solution {
public:
 bool *flag;
 int len;
 vector<int> result;
 vector<int> copy;
 int sum;
 vector<int> findSubstring(string S, vector<string> &L) {
 result.clear();
 if(L.size() <= 0) return result;
 map<string,int> mapr;
 mapr.clear();
 vector<vector<int>> rtable;
 rtable.clear();
 len = L[0].size();
 map<string,int>::iterator it;
 for(int i = 0; i < L.size(); i++) {
 it = mapr.find(L[i]);
 if(it != mapr.end()) {
 it->second += 1;
 }
 else
 mapr.insert(map<string,bool>::value_type(L[i],1));
 }
 copy.clear();
 sum = 0;
 for(it = mapr.begin(); it != mapr.end(); it++) {
 copy.push_back(it->second);
 sum += it->second;
 }
 bfs(mapr, S, 0);
 return result;
 }
private:
 void bfs(map<string,int> &mapr, string &S, int start) {
 if(S.length() - start < sum * len) return;
 int position;
 map<string,int>::iterator it;
 int min = S.length();
 for(it = mapr.begin(); it != mapr.end(); it++) {
 string item = it->first;
 if((position = S.find(item,start)) == string::npos) return;
 if(position < min)
 min = position;
 }
 int i = 0;
 int end;
 if(bfsStep(mapr,min,S,end)) {
 end = min + 1;
 result.push_back(min);
 }
 end = min + 1;
 if(end >= S.length()) return;
 return bfs(mapr, S, end);
 }
 void resetMapr(map<string,int> &mapr) {
 int i = 0;
 map<string,int>::iterator it;
 for(it = mapr.begin(); it != mapr.end(); it++) {
 it->second = copy[i++];
 }
 }
 bool bfsStep(map<string,int> &mapr, int pos, string &S, int &end) {
 int count = 0;
 map<string,int>::iterator it;
 int i;
 for(i = pos; i < S.length(); i+=len) {
 it = mapr.find(string(S, i, len));
 if(it == mapr.end() || it->second <= 0) {
 end = i+len;
 resetMapr(mapr);
 return false;
 }
 it->second--;
 count++;
 if(count == sum) {
 resetMapr(mapr);
 return true;
 }
 }
 resetMapr(mapr);
 if(count == sum) return true;
 end = i;
 return false;
 }
};

[leetcode_91]Decode Ways

Sat, 23 May 2015 03:11:56 +0000

A message containing letters from A-Z is being encoded to numbers using the following mapping:

‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26

Given an encoded message containing digits, determine the total number of ways to decode it.

For example,
Given encoded message “12”, it could be decoded as “AB” (1 2) or “L” (12).

The number of ways decoding “12” is 2.

开始用搜索，超时。

后来一想如果从后面前找，这样的话很多多余的状态不仅存下来了，而且不会重复计算。

然后注意0存在的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 int counts[10000];
 int numDecodings(string s) {
 if(s.length() <= 0 || (s.length() == '1' && s[0] == '0'))return 0;
 if(s[s.length()-1] != '0')counts[s.length() - 1] = 1;
 else counts[s.length()-1] = 0;
 counts[s.length()] = 1;
 for(int i = s.length()-2;i >= 0;i--) {
 if(s[i] == '0') {
 counts[i] = 0;
 continue;
 }
 if(s[i] == '1' || (s[i] == '2'&&s[i+1] <= '6'))counts[i] = counts[i+1] + counts[i+2];
 else
 counts[i] = counts[i+1];
 }
 return counts[0];
 }
};

[leetcode_149]Max Points on a Line

Sat, 23 May 2015 03:08:49 +0000

判断点集中，最多有多少点在一条直线上。
我看AC率这么低，手很抖，但是别的题越来越难，又写不出来。
于是想了一个n^3的复杂度，能不过么？欧克，我想了想可以优化一下，每条直线我都弄成：
ax + by + c = 0
且a一定为正数。
优化的地方是：hash_map：abc是否已经计算过。是一个不是很好的优化。
但是结果出人意料，不优化16ms，优化284ms原因是用的map，map的查找是logn而不是1
anyway。也不是一次过的，提示下注意重复点的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65


class Solution {
public:
 int maxPoints(vector<Point> &points) {
 vector<Point> pointstmp;
 pointstmp.clear();
 int counts[1000];
 for(int i = 0; i < points.size(); i++) {
 int tmp = 0;
 int j;
 for(j = 0; j < pointstmp.size(); j++) {
 if(pointstmp[j].x == points[i].x && pointstmp[j].y == points[i].y) {
 break;
 }
 }
 if(j < pointstmp.size()) {
 counts[j]++;
 } else {
 pointstmp.push_back(points[i]);
 counts[pointstmp.size()-1] = 1;
 }
 }
 if(pointstmp.size() == 0) return 0;
 if(pointstmp.size() == 1) return counts[0];
 if(pointstmp.size() == 2) return counts[0] + counts[1];
 int ans = 2;
 map<vector<int>, bool> mapv;
 mapv.clear();
 for(int i = 0; i < pointstmp.size()-2; i++) {
 for(int j = i+1; j < pointstmp.size()-1; j++) {
 int x1 = pointstmp[i].x;
 int y1 = pointstmp[i].y;
 int x2 = pointstmp[j].x;
 int y2 = pointstmp[j].y;
 if(x1 == x2 && y1 == y2) continue;
 int a = y1 - y2;
 int b = -(x1 - x2);
 int c = (x1 - x2) * y1 - (y1 - y2) * x1;
 // if(a < 0) {
 // a = a * (-1);
 // b = b * (-1);
 // c = c * (-1);
 // }
 // vector<int> tmp;
 // tmp.clear();
 // tmp.push_back(a);
 // tmp.push_back(b);
 // tmp.push_back(c);
 // if(mapv.find(tmp) != mapv.end()) continue;
 // mapv.insert(map<vector<int>, bool>::value_type(tmp, true));
 int count = counts[i] + counts[j];
 for(int k = j+1; k < pointstmp.size(); k++) {
 int x = pointstmp[k].x;
 int y = pointstmp[k].y;
 if(isInLine(a, b, c, x, y)) count += counts[k];
 }
 if(count > ans) ans = count;
 }
 }
 return ans;
 }
private:
 bool isInLine(int a, int b, int c, int x, int y) {
 return a * x + b * y + c == 0;
 }
};

[leetcode_132]Palindrome Partitioning II

Sat, 23 May 2015 03:07:49 +0000

开始使用搜索，TLE:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 int ans;
 int minCut(string s) {
 ans = 0xffffff;
 if(s.length() <= 0)return ans;
 bool *flag = new bool[s.length()+1];
 for(int i = 0;i <= s.length();i++)
 flag[i] = false;
 flag[0] = true;
 PartitionStep(s,1,flag);
 return ans;
 }
private:
 void PartitionStep(string s,int step,bool *flag) {
 if(step == s.length()) {
 int i;
 flag[step] = true;
 for(i = step-1;i >= 0;i--) {
 if(flag[i] == true)break;
 }
 if(IsPalindrome(s,i,step-1)) {
 int count = 0;
 for(int i = 0;i <=step;i++) {
 if(flag[i] == true)count++;
 }
 if(count-2 < ans)ans = count-2;
 }
 flag[step] =false;
 return ;
 }
 flag[step] = true;
 int i;
 for(i = step-1;i >= 0;i--) {
 if(flag[i] == true)break;
 }
 if(IsPalindrome(s,i,step-1)) {
 PartitionStep(s,step+1,flag);
 }
 flag[step] = false;
 PartitionStep(s,step+1,flag);
 }
 bool IsPalindrome(string s,int i,int j) {
 while(i < j) {
 if(s[i] != s[j])return false;
 i++;
 j--;
 }
 return true;
 }
};

后来使用DP，惭愧研究了别人的思想：
http://blog.csdn.net/doc_sgl/article/details/13418125

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 int minCut(string s) {
 int lens = s.length();
 bool **isP;
 isP = new bool *[lens];
 for(int i = 0;i < lens;i++) {
 isP[i] = new bool [lens];
 for(int j = 0;j < lens;j++) {
 isP[i][j] = false;
 }
 }
 for(int i = 0;i < lens;i++)
 isP[i][i] = true;

 int * dp = new int[lens+1];
 for(int i = lens;i >= 0;i--)
 dp[i] = lens - 1 - i;
 for(int i = lens-1;i >= 0;i--) {
 for(int j = i;j < lens;j++) {
 if(((j - i) <= 2 || isP[i+1][j-1]) && s[i] == s[j]) {
 isP[i][j] = true;
 dp[i] = dp[i] > dp[j+1]+1?dp[j+1]+1:dp[i];
 }
 }
 }
 return dp[0];
 }
};

[leetcode_124]Binary Tree Maximum Path Sum

Sat, 23 May 2015 03:06:12 +0000

求出二叉树中的距离和。
Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:
Given the below binary tree,

Return 6.

递归寻找所有情况，针对每个点是：max(只取该点，左子树贡献的最大值+该点，左子树贡献的最大值+该点+右子树贡献的最大值，该点+右子树的最大值)。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


class Solution {
public:
 int result;
 int maxPathSum(TreeNode *root) {
 result = 0x80000001;
 if(root != NULL) {
 queryNodes(root);
 }
 return result;
 }
private:
 void queryNodes(TreeNode *node) {
 if(node->left == NULL && node->right == NULL) {
 if(node->val > result) result = node->val;
 return;
 }
 if(node->left == NULL) {
 queryNodes(node->right);
 node->val = node->val + node->right->val >= node->val ? node->val + node->right->val : node->val;
 if(node->val > result) result = node->val;
 return;
 }
 if(node->right == NULL) {
 queryNodes(node->left);
 node->val = node->val + node->left->val >= node->val ? node->val + node->left->val : node->val;
 if(node->val > result) result = node->val;
 return;
 }
 queryNodes(node->right);
 queryNodes(node->left);
 if(node->val > result) result = node->val;
 if(node->val + node->left->val > result) result = node->val + node->left->val;
 if(node->val + node->right->val > result) result = node->val + node->right->val;
 if(node->val + node->right->val + node->left->val > result) result = node->val + node->right->val + node->left->val;
 int max = node->val + node->left->val >= node->val + node->right->val ? node->val + node->left->val : node->val + node->right->val;
 node->val = max >= node->val ? max : node->val;
 }
};

[leetcode_143]Reorder List

Sat, 23 May 2015 03:05:13 +0000

单链表的基本处理，涉及逆序，计算长度等操作。
题意要求：
1->2->3->4 => 1->4->2->3 间隔操作。
Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 void reorderList(ListNode *head) {
 int len = getLength(head);
 if(len <= 2)return ;
 int pos = len%2==0?len/2:len/2+1;
 ListNode * headend = getListNode(head,pos-1);
 ListNode * head2 = getListNode(head,pos);
 headend -> next = NULL;
 head2 = reverseListNode(head2);
 ListNode * headc = head;
 while(head2 != NULL) {
 ListNode * headnext = head->next;
 ListNode * head2next = head2->next;
 head->next = head2;
 head2->next = headnext;
 head = headnext;
 head2 = head2next;
 }
 head = headc;
 }
private:
 ListNode * reverseListNode(ListNode * head) {
 ListNode * before = head;
 ListNode * now = head->next;
 while(now != NULL) {
 ListNode * next = now->next;
 now->next = before;
 before = now;
 now = next;
 }
 head->next = NULL;
 return before;
 }
 int getLength(ListNode *head) {
 int len = 0;
 while(head != NULL) {
 len++;
 head = head->next;
 }
 return len;
 }
 ListNode *getListNode(ListNode *head,int pos) {
 int i = 0;
 while(i < pos) {
 head = head->next;
 i++;
 }
 return head;
 }
};

[leetcode_10]Regular Expression Matching

Sat, 23 May 2015 03:04:11 +0000

搜索+剪枝，不过有一个很奇怪的地方就是一组测试数据过不了，加了一个针对测试数据的剪枝才AC的。所以，还是应该弄弄DP的方法。当时一直想用贪心，显然涉及到很多地方的回溯，贪心的方法不好使。另外注意a* 认为是一体的就是它代表空，多个a形成的串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Solution {
public:
 bool result;
 bool isMatch(const char *s, const char *p) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 result = false;
 int lens = strlen(s);
 int lenp = strlen(p);
 if(p[lenp-1] != '*' && s[lens-1] != p[lenp-1] && p[lenp-1]!='.')return result;
 matchStep(s,p);
 return result;
 }
private:
 void matchStep(const char * s,const char * p) {
 if(result)return;
 if(*s == '\0' && *p == '\0') {
 result = true;
 return;
 }
 if(*s == '\0') {
 if(*(p+1) == '*') {
 matchStep(s,p+2);
 return ;
 }
 }
 if(*s == '\0' || *p == '\0')return;
 if(*(p+1) != '\0') {
 if(*(p+1) != '*') {
 if(*s == *p || *p == '.') {
 matchStep(s+1,p+1);
 }
 else
 return;
 }
 else {
 if(*s != *p && *p != '.') {
 matchStep(s,p+2);
 }
 else {
 matchStep(s,p+2);
 matchStep(s+1,p);
 matchStep(s+1,p+2);
 }
 }
 }
 else {
 if(*s == *p || *p == '.') {
 matchStep(s+1,p+1);
 }
 else
 return;
 }
 }
};

[leetcode_28]Implement strStr()

Sat, 23 May 2015 03:02:31 +0000

本来想用kmp但是getnext写出来太扯淡超时。
最近真心累了，暂停一段时间吧。用朴素的模式匹配过了。
隔断时间再练习，最近看看里奇的原版C程序设计语言和深入理解计算机系统吧。真心累了，压力还大。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class Solution {
public:
 char *strStr(char *haystack, char *needle) {
 int lenh = strlen(haystack);
 int lenn = strlen(needle);
 if(lenh == 0 && lenn == 0)return haystack;
 for(int i = 0;i < lenh;i++) {
 if(strlen(haystack + i) >= lenn&&isEqual(haystack,i,needle))return haystack + i;
 }
 return NULL;
 }
private:
 bool isEqual(char *haystack,int i,char * needle) {
 int j;
 for(j = 0;j < strlen(needle);j++) {
 if(needle[j] != haystack[i+j])break;
 }
 if(j == strlen(needle))return true;
 else return false;
 }
};

KMP:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class Solution {
public:
 int lenh;
 int lenn;
 int *next;
 char *strStr(char *haystack, char *needle) {
 lenh = strlen(haystack);
 lenn = strlen(needle);
 if(lenn == 0)return haystack;
 if(lenh < lenn)return NULL;
 next = new int[lenn];
 getNext(needle);
 int k = 0;
 int j = 0;
 while(j < lenh) {
 if(k == -1 || needle[k] == haystack[j]) {
 k++;
 j++;
 if(k == lenn)return haystack + j - lenn;
 }
 else
 k = next[k];
 }
 return NULL;
 }
private:
 void getNext(char *needle) {
 int k = -1;
 int j = 0;
 next[j] = k;
 while(j < lenn-1) {
 if(k == -1 || needle[k] == needle[j]) {
 k++;
 j++;
 next[j] = k;
 }
 else
 k = next[k];
 }
 }
};

[leetcode_65]Valid Number

Sat, 23 May 2015 03:00:04 +0000

这个题判断一个数是否为数，不过输入样例太扯。。。或许是自己太水，我的定义和样例的定义不一样，改了好久，难怪这个题的AC率这么低。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


class Solution {
public:
 bool isNumber(const char *s) {
 string str = "";
 int len = strlen(s);
 int i = 0;
 for(;i < len;i++) {
 if(s[i] == ' ')continue;
 else break;
 }
 for(;i < len;i++) {
 str.push_back(s[i]);
 }
 for(int i = str.length()-1;i >= 0;i--) {
 if(str[i] == ' ') {
 str.erase(i);
 }
 else
 break;
 }
 return isNumberString(str);
 }
private:
 bool isNumberString(string s) {
 //是否有正负号
 //是否带小数点
 //是否含e
 //是否有前置0
 int len = s.length();
 if(len <= 0)return false;
 if(len == 1) {
 if(s[0] < '0' || s[0] > '9')return false;
 else return true;
 }
 int start = 0;
 if(s[0] == '+' || s[0] == '-') {
 start = 1;
 }
 bool isZeroAllowed = true;
 bool isPotAllowed = false;
 bool isEallowed = false;

 bool once = true;

 if(s[start] == '.') {
 if(len >= start + 2) {
 if(s[start + 1] >= '0' && s[start + 1] <= '9') {
 isZeroAllowed = true;
 isPotAllowed = false;
 isEallowed = true;
 once = false;
 start = start + 2;
 }
 else
 return false;
 }
 else
 return false;
 }
 for(int i = start;i < len;i++) {
 if(s[i] == '.' && isPotAllowed == false) {
 return false;
 }
 if(s[i] == '.' && isPotAllowed == true) {
 isPotAllowed = false;
 continue;
 }
 if(s[i] == 'e' && isEallowed == false) {
 return false;
 }
 if(s[i] == 'e' && isEallowed == true) {
 isEallowed = false;
 isPotAllowed = false;
 once = false;
 if(i + 1 >= len)return false;
 if(s[i+1] == '-' || s[i+1] == '+') {
 if(i+2 >= len)return false;
 if(s[i+2] < '0' || s[i+2] > '9')return false;
 i+=2;
 continue;
 }
 if(s[i+1] < '0' || s[i+1] > '9')return false;
 continue;
 }
 if(s[i] >= '0' && s[i] <= '9') {
 if(once == true) {
 isZeroAllowed = true;
 isPotAllowed = true;
 isEallowed = true;

 once = false;
 }
 continue;
 }
 return false;
 }
 return true;
 }
};

[leetcode_29]Divide Two Integers

Sat, 23 May 2015 02:58:15 +0000

模拟整数除法，不能用乘法，模，除法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 double exp[100];
 int divide(int dividend, int divisor) {
 return divided(dividend, divisor);
 }
private:
 int divided(double dividend, double divisor) {
 int flag = 1;
 if((dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0))
 flag = -1;
 if(dividend < 0) {
 dividend = abs(dividend);
 }
 if(divisor < 0) {
 divisor = abs(divisor);
 }
 int i = 0;
 exp[i++] = divisor;
 while(exp[i-1] < dividend) {
 exp[i++] = exp[i-1] + exp[i-1];
 }
 int ans = 0;
 i--;
 while(i >= 0) {
 if(dividend >= exp[i]) {
 ans += (int)pow(2.0, i);
 dividend -= exp[i];
 }
 else {
 i--;
 }
 }
 if(flag == -1) return ~ans + 1;
 else return ans;
 }
};

[leetcode_150] Evaluate Reverse Polish Notation

Sat, 23 May 2015 02:57:15 +0000

逆波兰表达式，用栈即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


class Solution {
public:
 int evalRPN(vector<string> &tokens) {
 stack<int> st;
 for(int i = 0; i < tokens.size(); i++) {
 if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
 int num1 = st.top();
 st.pop();
 int num2 = st.top();
 st.pop();
 if(tokens[i] == "+") {
 st.push(num1 + num2);
 }
 else if(tokens[i] == "-") {
 st.push(num2 - num1);
 }
 else if(tokens[i] == "*") {
 st.push(num1 * num2);
 }
 else if(tokens[i] == "/") {
 st.push(num2 / num1);
 }
 }
 else {
 st.push(genNum(tokens[i]));
 }
 }
 return st.top();
 }
private:
 int genNum(string s) {
 int flag = 1;
 if(s[0] == '-') {
 flag = -1;
 s = string(s, 1);
 }
 int num = 0;
 for(int i = s.length() - 1; i >= 0; i--) {
 num += (s[i] - '0') * (int)pow(10.0, (int)s.length() - 1 - i);
 }
 return num * flag;
 }
};

[leetcode_135]Candy

Sat, 23 May 2015 02:56:07 +0000

小朋友排在一排分糖果。每个小朋友至少有一个糖果，但是每个小朋友有个排名，排名高的小朋友比“邻居”的糖果要多。
问至少多少个糖果？
顺序模拟，假设第一个小朋友拿一个，如果后面的小朋友比他排名低，显然后面的小朋友拿后一个，前一个小朋友升一个。可以考虑到，需要记录，每个小朋友前面有多少个比他“连续一直”排名高的。
如果后面的小朋友排名比他高，后面的小朋友比前一个小朋友多拿一个，依次模拟即可。但是Wrong Answer了很多次T_T.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Solution {
public:
 int candy(vector<int> &ratings) {
 int len = ratings.size();
 if(len == 0 || len == 1)return len;
 vector<int>bigger(ratings.size(),0);
 int count = 1;
 int now = 1;
 int max = 0;
 int i;
 for(i = 1;i < ratings.size();i++) {
 if(ratings[i] > ratings[i-1]) {
 if(max != 0) {
 if(bigger[i-1] < max-1) {
 count += max-1 - bigger[i-1];
 }
 }
 max = 0;
 bigger[i] = 0;
 now += 1;
 count += now;
 }
 else
 if(ratings[i] < ratings[i-1]) {
 bigger[i] = bigger[i-1] + 1;
 if(now == 1) {
 count += bigger[i] + now;
 }
 else {
 max = now;
 now = 1;
 count += bigger[i] + now - (max-1);
 }
 }
 else {
 if(max != 0) {
 if(bigger[i-1] < max-1) {
 count += max-1 - bigger[i-1];
 }
 }
 max = 0;
 bigger[i] = 0;
 now = 1;
 count += 1;
 }
 }
 if(max != 0) {
 if(bigger[i-1] < max-1) {
 count += max-1 - bigger[i-1];
 }
 }
 return count;
 }
};

[leetcode_71]Simplify Path

Sat, 23 May 2015 02:55:03 +0000

将输入路径简化了unix风格的路径。栈即可解决。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 string simplifyPath(string path) {
 vector<string> paths;
 paths.clear();
 char * split = strtok(const_cast<char*>(path.c_str()), "/");
 while(split != NULL) {
 paths.push_back(split);
 split = strtok(NULL, "/");
 }
 stack<char*> st;
 for(int i = 0; i < paths.size(); i++) {
 if(strcmp(paths[i], ".") == 0) continue;
 if(strcmp(paths[i], "..") == 0) {
 if(!st.empty()) st.pop();
 }
 else {
 st.push(paths[i]);
 }
 }
 paths.clear();
 while(!st.empty()) {
 paths.push_back(st.top());
 st.pop();
 }
 string spath = "";
 for(int i = paths.size() - 1; i >= 0; i--) {
 spath = spath + string("/");
 spath = spath + string(paths[i]);
 }
 if(spath == "")
 spath = spath + string("/");
 return spath;
 }
};

[leetcode_139]Word Break

Sat, 23 May 2015 02:53:55 +0000

给定字典，判断输入单词是否可以拆分为字典中的单词。
暴力+剪枝。
开始超时，额外地判定，当前的字符是否都在字典中存在即可。但是我感觉钻了测试数据的空子。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution {
public:
 bool result;
 bool letters[26];
 bool wordBreak(string s, unordered_set<string> &dict) {
 result = false;
 for(int i = 0;i < 26;i++)
 letters[i] = false;
 for(string it:dict) {
 for(int i = 0;i < it.length();i++) {
 letters[it[i] - 'a'] = true;
 }
 }
 for(int i = s.length();i > 0;i--) {
 if(existLetters(string(s,0,i)) == false)return false;
 if(dict.find(string(s,0,i)) != dict.end()) {
 if(i == s.length())return true;
 else {
 wordBreakStep(s,i,dict);
 }
 }
 }
 return result;
 }
private:
 bool existLetters(string s) {
 for(int i = 0;i < s.length();i++) {
 if(letters[s[i] - 'a'] == false)return false;
 }
 return true;
 }
 void wordBreakStep(string s,int start,unordered_set<string> &dict) {
 if(result == true)return;
 for(int i = s.length() - start;i > 0;i--) {
 if(existLetters(string(s,start,i)) == false)return;
 if(dict.find(string(s,start,i)) != dict.end()) {
 if(i == s.length()-start) {
 result = true;
 return;
 }
 else {
 wordBreakStep(s,start + i,dict);
 }
 }
 }
 }
};

[leetcode_97]Interleaving String

Sat, 23 May 2015 02:52:47 +0000

给定串s1,s2，计算s3是否为s1和s2顺序叠加的串。
这个题开始模拟，但是有一个问题，如果s1[p1]和s2[p2]同时都等于s3[p3]怎么办，这个时候如果选择的话就需要预存状态然后开始搜索。
果然超时。
网上有人说用DP
f[i][j] = f[i-1][j] + s1[i] && s1[i] == s3[k]
f[i][j] = f[i][j-1](i+j = k) && s2[j] == s3[j]
s3串中的第k个字符完全匹配是需要s1串中的第i个字符或者s2串中的第j个字符相等才行。
枚举所有情况，最多n^2
输出f[i][j] i = s1.length() j = s2.length() i+j = s3.length()即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 bool ***f;
 bool isInterleave(string s1, string s2, string s3) {
 if(s1.length() + s2.length() != s3.length())return false;
 bool f[500][500];
 for(int i = 0;i < 500;i++) {
 for(int j = 0;j < 500;j++) {
 f[i][j] = false;
 }
 }
 f[0][0] = true;
 for(int i = 1;i <= s3.length();i++) {
 for(int j = 0;j < i;j++) {
 if(f[j][i-1-j] && i-1-j<=s2.length() && j+1 <= s1.length() && s1[j] == s3[i-1]) {
 f[j+1][i-1-j] = true;
 }
 if(f[j][i-1-j] && j <= s1.length() && i-1-j+1 <= s2.length() && s2[i-1-j] == s3[i-1]) {
 f[j][i-1-j+1] = true;
 }
 }
 }
 return f[s1.length()][s2.length()];
 }
};

[leetcode_32]Longest Valid Parentheses

Sat, 23 May 2015 02:51:31 +0000

求最长的满足括号关系的对应子串。栈记录即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 int longestValidParentheses(string s) {
 stack<int> st;
 st.push(-1);
 int max = 0;
 int i = 0;
 while(i < s.length()) {
 int top = st.top();
 if(top == -1) {
 st.push(i);
 }
 else {
 if(s[top] == '(' && s[i] == ')') {
 st.pop();
 }
 else {
 st.push(i);
 }
 }
 i++;
 }
 int now = s.length();
 while(!st.empty()) {
 int before = st.top();
 st.pop();
 if((now - 1 - before) % 2 == 0 && now - 1 - before > max)
 max = now - 1 - before;
 now = before;
 }
 return max;
 }
};

[leetcode_79]Word Search

Sat, 23 May 2015 02:44:16 +0000

简单搜索题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 bool result;
 bool exist(vector<vector<char>> &board, string word) {
 vector<vector<int>> flag;
 flag.clear();
 for(int i = 0; i < board.size(); i++) {
 vector<int> item(board[i].size(), 0);
 flag.push_back(item);
 }
 result = false;
 int pos = 0;
 for(int i = 0; i < board.size(); i++) {
 for(int j = 0; j < board[i].size(); j++) {
 if(flag[i][j] == 0 && board[i][j] == word[pos]) {
 flag[i][j] = 1;
 pos++;
 existStep(board, flag, word, i, j, pos);
 pos--;
 flag[i][j] = 0;
 }
 }
 }
 return result;
 }
private:
 void existStep(vector<vector<char>> &board, vector<vector<int>> &flag, string word, int x, int y, int pos) {
 if(result) return;
 if(pos >= word.length()) {
 result = true;
 return;
 }
 int walk[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
 for(int i = 0; i < 4; i++) {
 int xn = x + walk[i][0];
 int yn = y + walk[i][1];
 if(xn < 0 || xn >= board.size() || yn < 0 || yn >= board[0].size()) continue;
 if(flag[xn][yn] == 1 || board[xn][yn] != word[pos]) continue;
 flag[xn][yn] = 1;
 pos++;
 existStep(board, flag, word, xn, yn, pos);
 pos--;
 flag[xn][yn] = 0;
 }
 }
};

[leetcode_85] Maximal Rectangle

Sat, 23 May 2015 02:43:10 +0000

这个题暴力做的，之前用栈解决直方图最大值的算法最坏情况好像比较高。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class Solution {
public:
 int maximalRectangle(vector<vector<char>> &matrix) {
 int max = 0;
 int **map = new int*[matrix.size()];
 for(int i = 0; i < matrix.size(); i++) {
 map[i] = new int[matrix[0].size()];
 }
 for(int i = 0; i < matrix.size(); i++) {
 int height = 0;
 for(int j = matrix[0].size() - 1; j >= 0; j--) {
 if(matrix[i][j] == '1') map[i][j] = ++height;
 else {
 height = 0;
 map[i][j] = height;
 }
 }
 }
 for(int i = 0; i < matrix.size(); i++) {
 for(int j = 0; j < matrix[0].size(); j++) {
 int width = map[i][j];
 max = Max(max, width);
 for(int k = i + 1; k < matrix.size(); k++) {
 if(map[k][j] == 0) break;
 else {
 width = Min(width, map[k][j]);
 max = Max(max, width * (k - i + 1));
 }
 }
 }
 }
 return max;
 }
private:
 int Max(int a, int b) {
 return a > b ? a : b;
 }
 int Min(int a, int b) {
 return a < b ? a : b;
 }
};

[leetcode_43] Multiply Strings

Sat, 23 May 2015 02:42:03 +0000

大整数乘法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


class Solution {
public:
 string multiply(string num1, string num2) {
 string ans = "";
 int inbit;
 // gen table
 vector<vector<int>> table;
 table.clear();
 for(int i = num1.length()-1; i >= 0; i--) {
 vector<int> item;
 item.clear();
 inbit = 0;
 for(int k = 0; k < num1.length()-1-i; k++)
 item.push_back(0);
 for(int j = num2.length()-1; j >= 0; j--) {
 int tmp = (num1[i] - '0') * (num2[j] - '0') + inbit;
 inbit = tmp / 10;
 item.push_back(tmp % 10);
 }
 if(inbit != 0)
 item.push_back(inbit);
 table.push_back(item);
 }
 // calc ansint
 vector<int> ansint;
 ansint.clear();
 int len = table[table.size()-1].size();
 inbit = 0;
 for(int i = 0; i < len; i++) {
 int tmp = inbit;
 for(int j = 0; j < table.size(); j++) {
 if(table[j].size() > i) {
 tmp += table[j][i];
 }
 }
 inbit = tmp / 10;
 ansint.push_back(tmp % 10);
 }
 if(inbit != 0)
 ansint.push_back(inbit);
 bool flag = false;
 for(int i = ansint.size()-1; i >= 0; i--) {
 if(ansint[i] == 0 && i != 0 && flag == false) continue;
 ans.push_back(ansint[i] + '0');
 flag = true;
 }
 return ans;
 }
};

[leetcode_93]Restore IP Addresses

Sat, 23 May 2015 02:40:56 +0000

输出一个数字串能生成的所有ip地址。注意0的情况

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


class Solution {
public:
 vector<string> restoreIpAddresses(string s) {
 vector<string> ans;
 ans.clear();
 if(s.length() > 12)return ans;
 vector<int> split;
 split.clear();
 split.push_back(0);
 for(int i = 0;i < s.length();i++) {
 int num = genInt(split[split.size()-1],i,s);
 if(num >= 0&&num <= 255) {
 split.push_back(i);
 searchS(s,split,ans);
 split.pop_back();
 }
 }
 return ans;
 }
private:
 int genInt(int start,int end,string s) {
 string numstr(s,start,end-start+1);
 if(numstr.length() >= 4)return -1;
 if(end > start && s[start] == '0')return -1;
 int num = 0;
 bool flag = false;
 for(int i = numstr.length()-1;i >= 0;i--) {
 flag = true;
 num += (numstr[i] - '0')*(int)pow(10.0,(int)numstr.length() - 1 - i);
 }
 if(!flag)return -1;
 return num;
 }
 void searchS(string s,vector<int>& split,vector<string>& ans) {
 if(split.size() == 5) {
 string tmp = s;
 for(int i = 1;i < split.size()-1;i++) {
 tmp.insert(tmp.begin()+split[i]+i,'.');
 }
 ans.push_back(tmp);
 return;
 }
 if(split.size() == 4) {
 int numlast = genInt(split[split.size()-1]+1,s.length()-1,s);
 if(numlast >= 0&&numlast <= 255) {
 split.push_back(s.length()-1);
 searchS(s,split,ans);
 split.pop_back();
 }
 return;
 }
 for(int i = split[split.size()-1]+1;i < s.length();i++) {
 int num = genInt(split[split.size()-1]+1,i,s);
 if(num >= 0&&num <= 255) {
 split.push_back(i);
 searchS(s,split,ans);
 split.pop_back();
 }
 }
 }
};

[leetcode_54]Spiral Matrix

Sat, 23 May 2015 02:39:49 +0000

螺旋输出矩阵注意一行和一列的边界情况

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


class Solution {
public:
 vector<int> spiralOrder(vector<vector<int>> &matrix) {
 vector<int> ans;
 ans.clear();
 if(matrix.size() <= 0) return ans;
 int count = 0;
 int sum = matrix.size() * matrix[0].size();
 int px = 0;
 int py = 0;

 int xa = 0;
 int xb = matrix.size() - 1;
 int ya = 0;
 int yb = matrix[0].size() - 1;

 int dir = 0;
 while(count < sum) {
 ans.push_back(matrix[px][py]);
 switch(dir) {
 case 0:
 if(py == yb) {
 dir++;
 dir %= 4;
 xa++;
 px++;
 break;
 }
 py++;
 if(py == yb) {
 dir++;
 dir %= 4;
 xa++;
 }
 break;
 case 1:
 if(px == xb) {
 dir++;
 dir %= 4;
 yb--;
 py--;
 break;
 }
 px++;
 if(px == xb) {
 dir++;
 dir %= 4;
 yb--;
 }
 break;
 case 2:
 if(py == ya) {
 dir++;
 dir %= 4;
 xb--;
 px--;
 break;
 }
 py--;
 if(py == ya) {
 dir++;
 dir %= 4;
 xb--;
 }
 break;
 case 3:
 if(px == xa) {
 dir++;
 dir %= 4;
 ya++;
 py++;
 break;
 }
 px--;
 if(px == xa) {
 dir++;
 dir %= 4;
 ya++;
 }
 break;
 }
 count++;
 }
 return ans;
 }
};

[leetcode_57]Insert Interval

Sat, 23 May 2015 02:38:39 +0000

插入某个区间，然后输出合并后的结果。
偷了个懒，此题直接借用上题的合并即可。
但是实际上，题中说已经排好序了。
所以时间复杂度可以降到o（n）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


int cmp(Interval a, Interval b) {
 if (a.start == b.start)
 return a.end < b.end;
 return a.start < b.start;
}

class Solution {
public:
 vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
 intervals.push_back(newInterval);
 return merge(intervals);
 }
private:
 vector<Interval> merge(vector<Interval> &intervals) {
 sort(intervals.begin(), intervals.end(), cmp);
 vector<Interval> ans;
 ans.clear();
 if (intervals.size() <= 0) return ans;
 Interval item = intervals[0];
 for (int i = 1; i < intervals.size(); i++) {
 if (item.end < intervals[i].start) {
 ans.push_back(item);
 item = intervals[i];
 } else {
 if (item.end < intervals[i].end)
 item.end = intervals[i].end;
 }
 }
 ans.push_back(item);
 return ans;
 }
};

[leetcode_56]Merge Intervals

Sat, 23 May 2015 02:37:38 +0000

合并区间，先预处理排序。
然后每个区间枚举，看能不能合后面的合并即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


int cmp(Interval a, Interval b) {
 if(a.start == b.start)
 return a.end < b.end;
 return a.start < b.start;
}

class Solution {
public:
 vector<Interval> merge(vector<Interval> &intervals) {
 sort(intervals.begin(), intervals.end(), cmp);
 vector<Interval> ans;
 ans.clear();
 if(intervals.size() <= 0) return ans;
 Interval item = intervals[0];
 for(int i = 1; i < intervals.size(); i++) {
 if(item.end < intervals[i].start) {
 ans.push_back(item);
 item = intervals[i];
 }
 else {
 if(item.end < intervals[i].end)
 item.end = intervals[i].end;
 }
 }
 ans.push_back(item);
 return ans;
 }
};

[leetcode_37]Sudoku Solver

Sat, 23 May 2015 02:36:30 +0000

数独解法，哈哈，之前有个折磨了好久的题，我写过该解法，拿来改了改即可。
首先，网上有论文支持当已知点的个数小于17是无解的。
然后，暴力即可，暴力的技巧是：从可能性少的开始搜索。

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153


struct Pointxy {
 int x;
 int y;
 int val;
};
int cmp(Pointxy a, Pointxy b) {
 return a.val < b.val;
}
class Solution {
public:
 int bitarray[9];
 int map[9][9];
 bool result;
 int CountOnes(int v)
 {
 int number = 0;
 while(v)
 {
 v &= (v-1);
 number++;
 }
 return number;
 }
 int GetRegionOfBoard(int x, int y) {
 if(x >= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool RefeshMap(int x, int y){
 int set_tmp = 0;
 for(int i = 0; i < 9; i++) {
 if(CountOnes(map[x][i]) == 1) {
 set_tmp = set_tmp | map[x][i];
 }
 if(CountOnes(map[i][y]) == 1) {
 set_tmp = set_tmp | map[i][y];
 }
 }
 int region = GetRegionOfBoard(x, y);
 int x_r = (region / 3 + 1) * 3;
 int y_r = (region % 3 + 1) * 3;
 for(int i = x_r-3; i < x_r; i++) {
 for(int j = y_r-3; j < y_r; j++) {
 if(CountOnes(map[i][j]) == 1) {
 set_tmp = set_tmp | map[i][j];
 }
 }
 }
 if(set_tmp == 511)return false;
 map[x][y] = 511 - set_tmp;
 return true;
 }
 void Move(Pointxy pxy[81], int index, vector<vector<char>> &board) {
 if(result == true)return;
 if(index <= 0) {
 result = true;
 return;
 } else {
 sort(pxy, pxy+index, cmp);
 int pi = pxy[0].x;
 int pj = pxy[0].y;
 for(int ibit = 0; ibit < 9; ibit++) {
 if(result == true)return;
 if(map[pi][pj] & bitarray[ibit]) {
 if(pi == 0 && pj == 6) {
 int hujiulin = 1;
 }
 board[pi][pj] = ibit+1+'0';
 map[pi][pj] -= bitarray[ibit];
 int xtmp[81];
 int ytmp[81];
 int indextmp = 0;
 for(int i = 1; i < index; i++) {
 int xi = pxy[i].x;
 int yi = pxy[i].y;
 if(xi == pi || yi == pj || GetRegionOfBoard(xi, yi) == GetRegionOfBoard(pi, pj)) {
 if(map[xi][yi] & bitarray[ibit]) {
 xtmp[indextmp] = xi;
 ytmp[indextmp++] = yi;
 map[xi][yi] -= bitarray[ibit];
 }
 }
 }
 Pointxy pxyt[81];
 int indext = 0;
 for(int i = 1; i < index; i++) {
 pxyt[indext].x = pxy[i].x;
 pxyt[indext].y = pxy[i].y;
 pxyt[indext].val = CountOnes(map[pxyt[indext].x][pxyt[indext].y]);
 indext++;
 }
 Move(pxyt, indext, board);
 for(int i = 0; i < indextmp; i++) {
 int xi = xtmp[i];
 int yi = ytmp[i];
 map[xi][yi] += bitarray[ibit];
 }
 map[pi][pj] += bitarray[ibit];
 }
 }
 }
 }
 void solveSudoku(vector<vector<char>> &board) {
 for(int i = 0; i < 9; i++) {
 bitarray[i] = (int)pow(2.0, i);
 }
 int count = 0;
 for(int i = 0; i < 9; i++) {
 for(int j = 0; j < 9; j++) {
 if(board[i][j] == '.') {
 map[i][j] = 511;
 } else {
 map[i][j] = bitarray[board[i][j] - '0'-1];
 count++;
 }
 }
 }
 if(count < 17)return;
 Pointxy pxy[81];
 int index = 0;
 for(int i = 0; i < 9; i++) {
 for(int j = 0; j < 9; j++) {
 if(map[i][j] == 511) {
 if(RefeshMap(i, j) == false)return;
 pxy[index].x = i;
 pxy[index].y = j;
 pxy[index++].val = CountOnes(map[i][j]);
 }
 if(CountOnes(map[i][j]) == 1) {
 int k = 0;
 for(k = 0; k < 9; k++) {
 if(map[i][j] == bitarray[k])break;
 }
 board[i][j] = k+1+'0';
 }
 }
 }
 result = false;
 Move(pxy, index, board);
 }
};

[leetcode_138]Copy List with Random Pointer

Sat, 23 May 2015 02:35:14 +0000

指针的深拷贝。
来回用两次 map 即可在 nlogn 的时间复杂度下解决该问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


class Solution {
public:
 RandomListNode *copyRandomList(RandomListNode *head) {
 int length = getRandomList(head);
 if(length == 0)
 return NULL;
 int index = 0;
 RandomListNode * headb1 = head;
 map<RandomListNode *, int> map_ri;
 map_ri.clear();
 while(head != NULL) {
 map_ri.insert(map<RandomListNode *, int>::value_type(head, index++));
 head = head->next;
 }
 int *pos = new int[length];
 map<RandomListNode *, int>::iterator itri;
 index = 0;
 head = headb1;
 while(head != NULL) {
 itri = map_ri.find(head->random);
 if(itri == map_ri.end())
 pos[index++] = -1;
 else
 pos[index++] = itri->second;
 head = head->next;
 }
 head = headb1;
 map<int, RandomListNode *> map_r;
 map_r.clear();
 index = 0;
 RandomListNode *copy = new RandomListNode(head->label);
 RandomListNode *copymove = copy;
 map_r.insert(map<int, RandomListNode *>::value_type(index++, copymove));
 head = head->next;
 while(head != NULL) {
 RandomListNode * tmp = new RandomListNode(head->label);
 copymove->next = tmp;
 copymove = copymove->next;
 map_r.insert(map<int, RandomListNode *>::value_type(index++, copymove));
 head = head->next;
 }
 copymove = copy;
 index = 0;
 while(copymove != NULL) {
 map<int, RandomListNode *>::iterator it = map_r.find(pos[index++]);
 if(it == map_r.end())
 copymove->random = NULL;
 else
 copymove->random = it->second;
 copymove = copymove->next;
 }
 return copy;
 }
private:
 int getRandomList(RandomListNode *head) {
 int length = 0;
 while(head != NULL) {
 head = head->next;
 length++;
 }
 return length;
 }
};

[leetcode_87]Scramble String

Sat, 23 May 2015 02:33:57 +0000

这个题自己独立做出来的，还是很高兴的，前面有两个题把我打击得都快没信心了。一个数据过不了，一个方法想不到。
最开始想暴力，枚举每个间歇，只要满足左边和右边的字符串经过排序相等即可。
把这个思想，模拟一下，去找出现左边和左边相等的串即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


int cmp(char a,char b) {
 return a < b;
}
class Solution {
public:
 bool isScramble(string s1, string s2) {
 if(s1.length() != s2.length())return false;
 string s1t = s1;
 string s2t = s2;
 sort(s1.begin(),s1.end(),cmp);
 sort(s2.begin(),s2.end(),cmp);
 if(s1 != s2)return false;
 return checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 }
private:
 bool checkIs(string s1,string s2) {
 if(s1.length() <= 0)return true;
 if(s1.length() == 1) {
 if(s1[0] == s2[0])return true;
 else return false;
 }
 int i = 0;
 while(i < s1.length()) {
 if(s2[i] != s1[0]) {
 i++;
 continue;
 }
 string s1b(s1,1,i);
 string s2b(s2,0,i);
 sort(s1b.begin(),s1b.end(),cmp);
 sort(s2b.begin(),s2b.end(),cmp);
 if(s1b != s2b) {
 i++;
 continue;
 }
 else
 break;
 }
 if(i == s1.length())return false;
 if(i == s1.length()-1) {
 string s1t = string(s1,1,i);
 string s2t = string(s2,0,i);
 return checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 }
 string s1e(s1,i+1);
 string s2e(s2,i+1);
 sort(s1e.begin(),s1e.end(),cmp);
 sort(s2e.begin(),s2e.end(),cmp);
 if(s1e != s2e)return false;
 string s1t = string(s1,1,i);
 string s2t = string(s2,0,i);
 bool flag1 = checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 s1t = string(s1,i+1);
 s2t = string(s2,i+1);
 bool flag2 = checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 return flag1 && flag2;
 }
};

[leetcode_84]Largest Rectangle in Histogram

Sat, 23 May 2015 02:32:36 +0000

求直方图的最大面积
使用栈结构来解决这个问题。始终保持栈内的数据为单增，如果不是，出栈并计算。
参考：
http://blog.csdn.net/doc_sgl/article/details/11805519

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 int largestRectangleArea(vector<int> &height) {
 if(height.size() <= 0) return 0;
 height.push_back(-1);
 int max = 0x80000000;
 vector<int> stack;
 stack.clear();
 stack.push_back(0);
 for(int i = 1; i < height.size(); i++) {
 if(height[stack[stack.size()-1]] <= height[i]) stack.push_back(i);
 else {
 while(stack.size() > 0 && height[stack[stack.size() - 1]] > height[i]) {
 int heighttmpi = stack[stack.size()-1];
 stack.pop_back();
 if(stack.size() == 0) {
 if(height[heighttmpi] * (i-0) > max) max = height[heighttmpi] * (i-0);
 }
 else {
 if(height[heighttmpi] * (i-stack[stack.size()-1]-1) > max) max = height[heighttmpi] * (i-stack[stack.size()-1]-1);
 }
 }
 }
 stack.push_back(i);
 }
 return max;
 }
};

[leetcode_148]Sort List

Sat, 23 May 2015 02:28:03 +0000

单链表排序。
用快排，某组测试数组超时。郁闷。
后来发现某大牛自己写的快排也过不了该数据。于是照他的思路写了堆排序，但是空间复杂度就不是常数了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 ListNode *sortList(ListNode *head) {
 if(head == NULL || head->next == NULL) return head;
 map<int, vector<ListNode *>> map_nodes;
 map_nodes.clear();
 while(head != NULL) {
 if(map_nodes.find(head->val) == map_nodes.end()) {
 vector<ListNode *> item;
 item.clear();
 item.push_back(head);
 map_nodes.insert(pair<int, vector<ListNode *>>(head->val, item));
 } else {
 map<int, vector<ListNode *>>::iterator it = map_nodes.find(head->val);
 it->second.push_back(head);
 }
 head = head->next;
 }
 map<int, vector<ListNode *>>::iterator it = map_nodes.begin();
 head = it->second[0];
 ListNode *tmp = head;
 for(int i = 1; i < it->second.size(); i++) {
 tmp->next = it->second[i];
 tmp = tmp->next;
 }
 for(; it != map_nodes.end(); it++) {
 tmp->next = it->second[0];
 tmp = tmp->next;
 for(int i = 1; i < it->second.size(); i++) {
 tmp->next = it->second[i];
 tmp = tmp->next;
 }
 }
 tmp->next = NULL;
 return head;
 }
};

[leetcode_60]Permutation Sequence

Sat, 23 May 2015 02:26:50 +0000

求出[1,2,3,…,n]全排列的第k个数

纯暴力为超时，其实每隔一个数都可以排除一些数，不用每个数每个数的向上搜索。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


class Solution {
public:
 string getPermutation(int n, int k) {
 count = 0;
 flag = new bool[n+1];
 for(int i = 1;i <= n;i++) {
 flag[i] = false;
 }
 string ans = "";
 string result = "";
 for(int i = 1;i <= n;i++) {
 if(result != "") break;
 if(k > factorial(n-1) + count) {
 count += factorial(n-1);
 continue;
 }
 if(flag[i] == false) {
 flag[i] = true;
 ans.push_back(i + '0');
 getPermutationStep(n, k, 1, ans);
 ans.erase(ans.end()-1);
 flag[i] = false;
 }
 }
 return result;
 }
private:
 int count;
 bool *flag;
 string result;
 void getPermutationStep(int n, int k, int now, string ans) {
 if(result != "") return;
 if(now == n) {
 count++;
 if(k <= count) {
 result = ans;
 }
 return;
 }
 for(int i = 1;i <= n;i++) {
 if(flag[i] == false) {
 if(now==1 && k > factorial(n-now-1) + count) {
 count += factorial(n-now-1);
 continue;
 }
 flag[i] = true;
 ans.push_back(i + '0');
 getPermutationStep(n, k, now+1, ans);
 ans.erase(ans.end()-1);
 flag[i] = false;
 }
 }
 }
}
int factorial(int x) {
 int ans = 1;
 for(int i = 1;i <= x;i++) {
 ans *= i;
 }
 return ans;
}

[leetcode_61]Rotate List

Sat, 23 May 2015 02:25:25 +0000

给单链表一个k数量节点的旋转。
开始WA，后来发现需要对k取mod。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 ListNode *rotateRight(ListNode *head, int k) {
 int height = heightList(head);
 if(height == 0)return head;
 k %= height;
 if(height < k || head == NULL || head->next == NULL || k == 0)return head;
 k = height - k;
 ListNode * before = head;
 ListNode * now = head->next;
 k--;
 while(k > 0) {
 k--;
 before = now;
 now = now->next;
 }
 ListNode * tmp = head;
 while(tmp->next != NULL) {
 tmp = tmp->next;
 }
 tmp->next = head;
 before->next = NULL;
 return now;
 }
private:
 int heightList(ListNode * head) {
 int height = 0;
 while(head != NULL) {
 head = head->next;
 height++;
 }
 return height;
 }
};

[leetcode_18]4Sum

Sat, 23 May 2015 02:24:26 +0000

给定数组，找出数组中4个数之和为目标数的所有不重复情况。
o(n^3*logn)险过。应该有更快的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


int cmp(int a, int b) {
 return a < b;
}
class Solution {
public:
 vector<vector<int>> fourSum(vector<int> &num, int target) {
 sort(num.begin(), num.end(), cmp);
 vector<vector<int>> ans;
 ans.clear();
 if (num.size() <= 3) return ans;
 for (int i = 0; i < num.size() - 3; i++) {
 for (int j = i + 1; j < num.size() - 2; j++) {
 for (int k = j + 1; k < num.size() - 1; k++) {
 int val = target - (num[i] + num[j] + num[k]);
 if (val >= num[k + 1] && findTarget(k + 1, num.size() - 1, val, num)) {
 vector<int> item;
 item.clear();
 item.push_back(num[i]);
 item.push_back(num[j]);
 item.push_back(num[k]);
 item.push_back(val);
 if (!checkExist(ans, item))
 ans.push_back(item);
 }
 }
 }
 }
 return ans;
 }

private:
 bool checkExist(vector<vector<int>> &ans, vector<int> &item) {
 for (int i = 0; i < ans.size(); i++) {
 if (item == ans[i]) return true;
 }
 return false;
 }
 bool findTarget(int left, int right, int target, vector<int> &num) {
 if (left > right) return false;
 int mid = (left + right) / 2;
 if (num[mid] == target) return true;
 else if (num[mid] > target) {
 return findTarget(left, mid - 1, target, num);
 } else {
 return findTarget(mid + 1, right, target, num);
 }
 }
};

[leetcode_123]Best Time to Buy and Sell Stock III

Sat, 23 May 2015 02:23:19 +0000

Best Time to Buy and Sell Stock系列第三题。之前两题分别说可以买卖任意多次和只能买卖一次。
此题是买卖两次。
买卖两次，找个节点分割问题，就把问题变成两个买卖一次的问题。但是超时。时间复杂度要到o(n^2)
另外一个思路。
按照买卖一次的方法处理正序，逆序
然后存储到达每个点时的max值。线性解法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


class Solution {
public:
 int maxProfit(vector<int> &prices) {
 if(prices.size() <= 1) return 0;
 vector<int> dis;
 dis.clear();
 for(int i = 0; i < prices.size()-1; i++) {
 int val = prices[i+1] - prices[i];
 dis.push_back(val);
 }
 vector<int> cost;
 cost.clear();
 if(dis[0] <= 0) {
 cost.push_back(0);
 }
 else {
 cost.push_back(dis[0]);
 }
 for(int i = 1; i < dis.size(); i++) {
 if(cost[i-1] + dis[i] >= 0) {
 cost.push_back(cost[i-1] + dis[i]);
 }
 else {
 cost.push_back(0);
 }
 }
 int maxnow = 0;
 for(int i = 0; i < cost.size(); i++) {
 if(cost[i] < maxnow)
 cost[i] = maxnow;
 else {
 maxnow = cost[i];
 }
 }

 vector<int> cost_back;
 cost_back.clear();
 if(dis[dis.size()-1] <= 0) {
 cost_back.push_back(0);
 }
 else {
 cost_back.push_back(dis[dis.size()-1]);
 }
 for(int i = dis.size() - 2; i >= 0; i--) {
 if(cost_back[dis.size()-2-i] + dis[i] >= 0) {
 cost_back.push_back(cost_back[dis.size()-2-i] + dis[i]);
 }
 else {
 cost_back.push_back(0);
 }
 }
 maxnow = 0;
 for(int i = 0; i < cost_back.size(); i++) {
 if(cost_back[i] < maxnow)
 cost_back[i] = maxnow;
 else {
 maxnow = cost_back[i];
 }
 }
 int max = 0;
 for(int i = 0; i < cost.size(); i++) {
 if(cost.size() - 2 - i >= 0 && cost.size() - 2 - i < cost.size()) {
 if(max < cost[i] + cost_back[cost.size()-2-i]) {
 max = cost[i] + cost_back[cost.size()-2-i];
 }
 }
 else {
 if(max < cost[i])
 max = cost[i];
 }
 }
 return max;
 }
};

[leetcode_99]Recover Binary Search Tree

Sat, 23 May 2015 02:22:12 +0000

交换二叉搜索树的两个节点，要求复原。
不确定我的做法对不对，我只是在 value 的程度上把他们复原了。但是原文说不要破坏他们的结构？
想法很简单中序遍历+线性数组纠正

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


class Solution {
public:
 void recoverTree(TreeNode *root) {
 if(root == NULL)return ;
 treeArray.clear();
 inOrder(root);
 int x,y;
 int flag = 0;
 for(int i = 0;i < treeArray.size();i++) {
 if(i == 0 && treeArray[i] > treeArray[i+1] && i < treeArray.size()-1) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 if(i == treeArray.size()-1 && treeArray[i] < treeArray[i-1] && i > 0) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 if( i > 0 && i < treeArray.size()-1 && treeArray[i] > treeArray[i-1] && treeArray[i] > treeArray[i+1]) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 if( i > 0 && i < treeArray.size()-1 && treeArray[i] < treeArray[i-1] && treeArray[i] < treeArray[i+1] ) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 }
 if(flag == 0) {
 for(int i = 0;i < treeArray.size()-1;i++) {
 if(treeArray[i] > treeArray[i+1]) {
 x = i;
 y = i+1;
 break;
 }
 }
 }
 queryTree(root,x,y);
 }
private:
 vector<int> treeArray;
 void inOrder(TreeNode * root) {
 if(root->left != NULL)
 inOrder(root->left);
 treeArray.push_back(root->val);
 if(root->right != NULL)
 inOrder(root->right);
 }
 void queryTree(TreeNode * root,int x,int y) {
 if(root->val == treeArray[x]) {
 root->val = treeArray[y];
 }
 else
 if (root->val == treeArray[y]){
 root->val = treeArray[x];
 }
 if(root->left != NULL)
 queryTree(root->left,x,y);
 if(root->right != NULL)
 queryTree(root->right,x,y);
 }
};

[leetcode_125]Valid Palindrome

Sat, 23 May 2015 02:20:45 +0000

判断句子是否为回文：不区分大小写，不考虑非数字和字母的字符。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 bool isPalindrome(string s) {
 for(int i = 0; i < s.length(); i++) {
 if(s[i] >= 'A' && s[i] <= 'Z') {
 s[i] = 'a' + s[i] - 'A';
 }
 }
 int i = 0;
 int j = s.length() - 1;
 while(i < j) {
 while(!isALetter(s[i]) && i < j) i++;
 while(!isALetter(s[j]) && i < j) j--;
 if(i >= j) break;
 if(s[i] != s[j])
 return false;
 else {
 i++;
 j--;
 }
 }
 return true;
 }
private:
 bool isALetter(char c) {
 if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
 return true;
 else
 return false;
 }
};

[leetcode_41]First Missing Positive

Sat, 23 May 2015 02:19:42 +0000

开始只能用map做。不过显然没有达到常数的空间的要求。
参考：
http://blog.unieagle.net/2012/09/20/leetcode题目：first-missing-positive/

自己diy的hash厉害。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 int firstMissingPositive(int A[], int n) {
 for(int i = 0; i < n; i++) {
 if(A[i] <= 0)
 A[i] = n+2;
 }
 for(int i = 0; i < n; i++) {
 if(abs(A[i]) - 1 < n && A[abs(A[i]) - 1] > 0)
 A[abs(A[i]) - 1] *= (-1);
 }
 for(int i = 1; i <= n; i++) {
 if(A[i-1] >= 0)
 return i;
 }
 return n + 1;
 }
};

[leetcode_69]Sqrt(x)

Sat, 23 May 2015 02:18:28 +0000

sqrt模拟。注意两个int乘法可能越界。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 int sqrt(int x) {
 //x >= 0 0 ~ x/2
 if(x <= 0)return 0;
 int left = 1;
 int right = x / 2;
 bsearch(left, right, x);
 return ans;
 }
private:
 int ans;
 void bsearch(int left, int right, int x) {
 if(left >= right) {
 ans = left;
 if(1.0 * ans * ans > x)
 ans--;
 return;
 }
 int mid = (left + right) / 2;
 if(1.0 * mid * mid == x) {
 ans = mid;
 return;
 }
 else
 if(1.0 * mid * mid > x) {
 bsearch(left, mid-1, x);
 }
 else
 if(1.0 * mid * mid < x) {
 bsearch(mid+1, right, x);
 }
 }
};

[leetcode_23]Merge k Sorted Lists

Sat, 23 May 2015 02:17:22 +0000

K路归并排序。注意各种边界：比如指针为NULL或者vector空。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81


class Solution {
public:
 ListNode *mergeKLists(vector<ListNode *> &lists) {
 if(lists.size() <= 0)
 return NULL;
 while(lists.size() > 1) {
 vector<ListNode *>lists_tmp;
 lists_tmp.clear();
 ListNode * tmp;
 int i = 0;
 while (true) {
 tmp = merge2Lists(lists[2*i],lists[2*i+1]);
 lists_tmp.push_back(tmp);
 i++;
 if(2*i+1 == lists.size()) {
 lists_tmp.push_back(lists[2*i]);
 break;
 }
 if(2*i+1 > lists.size()) {
 break;
 }
 }
 lists.clear();
 lists = lists_tmp;
 }
 return lists[0];
 }
private:
 ListNode *merge2Lists(ListNode * list1,ListNode * list2) {
 ListNode * list = NULL;
 ListNode * list_c = NULL;
 while(list1 != NULL && list2 != NULL) {
 if(list1->val < list2->val) {
 if(list == NULL) {
 list = list1;
 list_c = list;
 }
 else {
 list_c->next = list1;
 list_c = list_c->next;
 }
 list1 = list1->next;
 }
 else {
 if(list == NULL) {
 list = list2;
 list_c = list;
 }
 else {
 list_c->next = list2;
 list_c = list_c->next;
 }
 list2 = list2->next;
 }
 }
 while(list1!=NULL) {
 if(list_c == NULL) {
 list_c = list1;
 list = list_c;
 list1 = list1->next;
 continue;
 }
 list_c->next = list1;
 list_c= list_c->next;
 list1 = list1->next;
 }
 while(list2!=NULL) {
 if(list_c == NULL) {
 list_c = list2;
 list = list_c;
 list2 = list2->next;
 continue;
 }
 list_c->next = list2;
 list_c= list_c->next;
 list2 = list2->next;
 }
 if(list_c != NULL)list_c->next = NULL;
 return list;
 }
};

[leetcode_45]Jump Game II

Sat, 23 May 2015 02:16:14 +0000

不停地扩展当前能到达的最远的地方。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 int jump(int A[], int n) {
 if (n <= 1) return 0;
 int min = -1;
 int max = 0;
 int maxstep = 0;
 int count = 0;
 while (true) {
 count++;
 for (int i = min + 1; i <= max; i++) {
 if (i + A[i] >= n - 1) {
 return count;
 }
 if (i + A[i] >= maxstep)
 maxstep = i + A[i];
 }
 min = max;
 max = maxstep;
 }
 return -1;
 }
};

[leetcode_49]Anagrams

Sat, 23 May 2015 02:14:55 +0000

给定多个字符串，找出那些Anagrams的字符串组。
Anagrams:eat ate eta
这个题排序，再排序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


int cmp(int a, int b) {
 return a < b;
}
struct Item {
 int index;
 string val;
};
int cmpitem(Item a, Item b) {
 return a.val < b.val;
}
class Solution {
public:
 vector<string> anagrams(vector<string> &strs) {
 vector<Item> strs_cpy;
 strs_cpy.clear();
 for(int i = 0; i < strs.size(); i++) {
 Item item;
 item.index = i;
 item.val = strs[i];
 sort(item.val.begin(), item.val.end(), cmp);
 strs_cpy.push_back(item);
 }
 sort(strs_cpy.begin(), strs_cpy.end(), cmpitem);
 vector<string> ans;
 ans.clear();
 int index = 0;
 for(int i = 1; i < strs_cpy.size(); i++) {
 if(strs_cpy[i].val == strs_cpy[index].val) {
 if(i - index == 1) {
 ans.push_back(strs[strs_cpy[index].index]);
 }
 ans.push_back(strs[strs_cpy[i].index]);
 } else {
 index = i;
 }
 }
 return ans;
 }
};

[leetcode_140]Combination Sum II

Fri, 22 May 2015 12:13:52 +0000

在数组中找寻一系列的数，之和为target。
搜索+剪枝。注意去重复和升序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 vector<vector<int>>ans;
 vector<vector<int>> combinationSum2(vector<int> &num, int target) {
 ans.clear();
 sort(num.begin(),num.end(),cmp);
 vector<int> seq;
 seq.clear();
 addStep(num,0,0,target,seq);
 return ans;
 }
private:
 bool isSeqInAns(vector<int> &seq) {
 for(int i = 0;i < ans.size();i++) {
 if(ans[i] == seq)return false;
 }
 return true;
 }
 void addStep(vector<int> &num,int sum,int k,int target,vector<int> &seq) {
 if(sum == target) {
 if(isSeqInAns(seq))
 ans.push_back(seq);
 return;
 }
 if(k >= num.size()) {
 return ;
 }
 if(sum + num[k] <= target) {
 seq.push_back(num[k]);
 addStep(num,sum+num[k],k+1,target,seq);
 seq.pop_back();
 }
 addStep(num,sum,k+1,target,seq);
 }
};

[leetcode_115]Distinct Subsequences

Fri, 22 May 2015 12:11:50 +0000

给定S串和T串，求S串中删掉任意字符后，有多少中方式能够构成T串。
开始暴力搜索超时。其实技巧没掌握好。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


struct PointS {
 int index;
 int count;
};
class Solution {
public:
 int ans;
 vector<PointS> seq;
 int numDistinct(string S, string T) {
 ans = 0;
 if(T.length() <= 0)return ans;
 seq.clear();
 for(int i = 0;i < S.length();i++) {
 if(S[i] == T[T.length()-1]) {
 PointS item;
 item.index = i;
 item.count = 1;
 seq.push_back(item);
 }
 }
 matchStep(T.length() - 2,S,T,seq);
 return ans;
 }
private:
 void matchStep (int now,string S,string T,vector<PointS>& seq) {
 if(now == -1) {
 for(int i = 0;i < seq.size();i++) {
 PointS item = seq[i];
 ans += item.count;
 }
 return ;
 }
 vector<PointS> seq_c;
 seq_c.clear();
 int i = 0;
 int bottom = 0;
 int sum = 0;
 for(int i = 0;i < seq.size();i++)
 sum += seq[i].count;
 while(i < seq.size()) {
 for(int j = bottom;j < seq[i].index;j++) {
 if(S[j] == T[now]) {
 PointS item;
 item.index = j;
 item.count = sum;
 seq_c.push_back(item);
 }
 }
 bottom = seq[i].index;
 sum -= seq[i].count;
 i++;
 }
 seq.clear();
 matchStep (now - 1,S,T,seq_c);
 }
};

[leetcode_134]Gas Station

Fri, 22 May 2015 12:10:46 +0000

100题了~纪念一下。
先求是否有可行解。
然后从每个节点出发。找到第一个能到底部的节点。
AC了。个人认为想法对的。但是不肯定。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int ans = -1;
 int sum = 0;
 for(int i = 0;i < gas.size();i++) {
 sum += gas[i];
 sum -= cost[i];
 }
 if(sum < 0)return ans;

 int now = 0;
 int i = 0;
 ans = 0;
 while(i < gas.size()) {
 now += gas[i] - cost[i];
 if(now < 0) {
 i++;
 now = 0;
 ans = i;
 }
 else
 i++;
 }
 return ans;
 }
};

[leetcode_25]Reverse Nodes in k-Group

Fri, 22 May 2015 12:09:33 +0000

单链表，k个节点的反序，如果长度不够k就不反序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 int len;
 ListNode *reverseKGroup(ListNode *head, int k) {
 len = getLength(head);
 if(len < k || head == NULL || k <= 1) {
 return head;
 }
 ListNode ** tmp = new ListNode *[2];
 tmp = reverseKStep(head,k);
 len -= k;
 head = tmp[0];

 ListNode * beforebackup = tmp[1];
 while(len >= k) {
 tmp = reverseKStep(beforebackup->next,k);
 len -= k;
 beforebackup->next = tmp[0];
 beforebackup = tmp[1];
 }
 return head;
 }

private:
 // 返回两个指针 第一个表示头 第二个表示最后一个节点
 ListNode **reverseKStep(ListNode *before,int k) {
 ListNode * beforebackup = before;
 ListNode * now = before->next;
 int count = 1;
 while(now != NULL && count < k) {
 count++;
 ListNode * next = now->next;
 now->next = before;
 before = now;
 now = next;
 }
 beforebackup->next = now;
 ListNode ** ans = new ListNode *[2];
 ans[0] = before;
 ans[1] = beforebackup;
 return ans;
 }
 int getLength(ListNode *head) {
 int lentmp = 0;
 while(head != NULL) {
 head = head->next;
 lentmp++;
 }
 return lentmp;
 }
};

[leetcode_72]Edit Distance

Fri, 22 May 2015 12:08:23 +0000

这是一个动态规划的题目。参考：
http://blog.csdn.net/abcjennifer/article/details/7735272
做到这儿的时候，真心已经感觉自己做不动了，其实题目也不复杂，感觉自己的脑子太笨了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


class Solution {
public:
 int minDistance(string word1, string word2) {
 len1 = word1.length();
 len2 = word2.length();
 initdptable();
 for(int i = 1;i <= len1;i++) {
 for(int j = 1;j <= len2;j++) {
 dpTable[i][j] = getMin(word1[i-1] == word2[j-1] ? dpTable[i-1][j-1]:dpTable[i-1][j-1] + 1,dpTable[i-1][j]+1,dpTable[i][j-1]+1);
 }
 }
 //displaydptable();
 return dpTable[len1][len2];
 }
private:
 int **dpTable;
 int len1,len2;
 int getMin(int a,int b,int c) {
 int min = a;
 if(min > b)min = b;
 if(min > c)min = c;
 return min;
 }
 void initdptable() {
 dpTable = new int *[len1+1];
 for(int i = 0;i <= len1;i++) {
 dpTable[i] = new int[len2+1];
 }
 for(int i = 0;i <= len1;i++) {
 dpTable[i][0] = i;
 }
 for(int i = 0;i <= len2;i++) {
 dpTable[0][i] = i;
 }
 }
 void displaydptable() {
 for(int i = 0;i <= len1;i++) {
 for(int j = 0;j <= len2;j++) {
 cout << dpTable[i][j] << " ";
 }
 cout << endl;
 }
 }
};

[leetcode_131]Palindrome Partitioning

Fri, 22 May 2015 12:07:00 +0000

找出所有的划分，满足条件：各划分中的字符串为回文。
基本思路是：

搜索
每个位置要么断开，要么不断断开，一旦断开，判断前面新生成的划分是否为回文，若是，继续查找，不是，该断开是无效的。
找到末尾，然后记录。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


class Solution {
public:
 vector<vector<string>> ans;
 vector<vector<string>> partition(string s) {
 ans.clear();
 if(s.length() <= 0) return ans;
 bool *flag = new bool[s.length()+1];
 for(int i = 0; i <= s.length(); i++)
 flag[i] = false;
 flag[0] = true;
 PartitionStep(s, 1, flag);
 return ans;
 }
private:
 void PartitionStep(string s, int step, bool *flag) {
 if(step == s.length()) {
 int i;
 flag[step] = true;
 for(i = step-1; i >= 0; i--) {
 if(flag[i] == true) break;
 }
 if(IsPalindrome(s, i, step-1)) {
 GenAnsItem(s, flag);
 }
 flag[step] = false;
 return;
 }
 flag[step] = true;
 int i;
 for(i = step-1; i >= 0; i--) {
 if(flag[i] == true) break;
 }
 if(IsPalindrome(s, i, step-1)) {
 PartitionStep(s, step+1, flag);
 }
 flag[step] = false;
 PartitionStep(s, step+1, flag);
 }

 bool IsPalindrome(string s, int i, int j) {
 while(i < j) {
 if(s[i] != s[j]) return false;
 i++;
 j--;
 }
 return true;
 }

 void GenAnsItem(string s, bool *flag) {
 vector<string> item;
 item.clear();
 int i = 1;
 int before = 0;
 while(i <= s.length()) {
 if(flag[i] == true) {
 string tmp = "";
 for(int j = before; j < i; j++) {
 tmp.push_back(s[j]);
 }
 item.push_back(tmp);
 before = i;
 }
 i++;
 }
 ans.push_back(item);
 }
};

[leetcode_82]Remove Duplicates from Sorted List II

Fri, 22 May 2015 12:05:39 +0000

删除单向链表中所有有重复值的节点。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 ListNode *deleteDuplicates(ListNode *head) {
 while(head != NULL && head->next != NULL && head->val == head->next->val) {
 while(head != NULL && head->next != NULL && head->val == head->next->val) {
 head = head->next;
 }
 if(head != NULL) {
 head = head->next;
 }
 }
 if(head == NULL || head->next == NULL)return head;
 ListNode * now = head->next;
 ListNode * node = head;
 while(now != NULL && now->next != NULL){
 while(now != NULL && now->next != NULL && now->val == now->next->val) {
 while(now != NULL && now->next != NULL && now->val == now->next->val) {
 now = now->next;
 }
 if(now != NULL) {
 now = now->next;
 }
 }
 node->next = now;
 node = node->next;
 if(node == NULL)break;
 now = node->next;
 }
 return head;
 }
};

[leetcode_17]Letter Combinations of a Phone Number

Fri, 22 May 2015 12:04:25 +0000

输入数字串，输出对应手机键盘上所有的字母串的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class Solution {
public:
 vector<string> ans;
 vector<string> letterCombinations(string digits) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<string> map = GenMap();
 ans.clear();
 string item = "";
 letterCStep(digits, 0, item, map);
 return ans;
 }
private:
 void letterCStep(string digits, int step, string item, vector<string>& map) {
 if (step >= digits.length()) {
 ans.push_back(item);
 return;
 } else {
 int index = digits[step] - '0';
 for (int i = 0; i < map[index].size(); i++) {
 item.push_back(map[index][i]);
 letterCStep(digits, step + 1, item, map);
 item.erase(item.end() - 1);
 }
 }
 }
 vector<string> GenMap() {
 vector<string> map;
 map.clear();
 map.push_back(" ");
 map.push_back("");
 map.push_back("abc");
 map.push_back("def");
 map.push_back("ghi");
 map.push_back("jkl");
 map.push_back("mno");
 map.push_back("pqrs");
 map.push_back("tuv");
 map.push_back("wxyz");
 return map;
 }
};

[leetcode_106]Construct Binary Tree from Preorder and Inorder Traversal

Fri, 22 May 2015 12:03:11 +0000

根据前序和中序遍历构造二叉树，保证val不重复。注意别超内存。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(preorder.size() <= 0 || inorder.size() <= 0)
 return NULL;
 TreeNode * root = buildTreeStep(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1);
 return root;
 }
private:
 TreeNode *buildTreeStep(vector<int> &preorder,int prea,int preb, vector<int> &inorder,int ina,int inb) {
 if(prea > preb || ina > inb)
 return NULL;
 int root = preorder[prea];
 int i;
 for(i = ina;i <= inb;i++) {
 if(inorder[i] == root) {
 break;
 }
 }
 //inorderleft:ina,i-1
 //inorderright,i+1,inb
 //preorderleft:prea+1,prea+1+(i-1)-ina
 //preorderright:prea+(i-1)-ina+1,preb
 TreeNode * node = new TreeNode(root);
 node->left = buildTreeStep(preorder,prea+1,prea+1+(i-1)-ina,inorder,ina,i-1);
 node->right = buildTreeStep(preorder,prea+1+(i-1)-ina+1,preb,inorder,i+1,inb);
 return node;
 }
};

[leetcode_106]Construct Binary Tree from Inorder and Postorder Traversal

Fri, 22 May 2015 12:01:32 +0000

根据中序和后序遍历，构造二叉树，保证val不重复。注意别超内存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 if(inorder.size() <= 0 || postorder.size() <= 0)
 return NULL;
 TreeNode * root = buildTreeStep(inorder,0,inorder.size()-1,postorder,0,postorder.size()-1);
 return root;
 }
private:
 TreeNode *buildTreeStep(vector<int> &inorder,int ina,int inb,vector<int>&postorder,int poa,int pob) {
 if(ina > inb || poa > pob)
 return NULL;
 int root = postorder[pob];
 int i;
 for(i = ina;i <= inb;i++) {
 if(inorder[i] == root)break;
 }
 //inleft: ina i-1
 //inright:i+1 inb
 //poleft:poa,(i-1) - ina + poa
 //poright:(i-1) - ina + poa + 1,pob-1
 TreeNode * node = new TreeNode(root);
 node->left = buildTreeStep(inorder,ina,i-1,postorder,poa,(i-1)-ina+poa);
 node->right = buildTreeStep(inorder,i+1,inb,postorder,(i-1) - ina+poa+1,pob-1);
 return node;<br />
 }
};

[leetcode_36]Valid Sudoku

Fri, 22 May 2015 11:59:32 +0000

这个题，哎哟我只想说我操。
开始题意理解错了，以为是判断某个数独是否有可行解，哎哟我擦，枚举？暴力。
用set集合做了一个各种超时啊：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136


struct PointOfBoard {
 set<int>set_p;
 bool IsExist;
 int val;
 PointOfBoard():IsExist(false),val(-1){set_p.clear();}
};
class Solution {
public:
 PointOfBoard POB[9][9];
 int x[81];
 int y[81];
 int index;
 bool result;
 int GetRegionOfBoard(int x,int y) {
 if(x>= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool GetSetOfPOB(int x,int y){
 set<int>set_tmp;
 set_tmp.clear();
 for(int i = 0;i < 9;i++) {
 if(POB[x][i].IsExist) {
 int val = POB[x][i].val;
 if(set_tmp.find(val) == set_tmp.end())
 set_tmp.insert(val);
 }
 if(POB[i][y].IsExist) {
 int val = POB[i][y].val;
 if(set_tmp.find(val) == set_tmp.end())
 set_tmp.insert(val);
 }
 }
 int region = GetRegionOfBoard(x,y);
 int x_r = (region / 3 + 1)*3;
 int y_r = (region % 3 + 1)*3;
 for(int i = x_r-3;i < x_r;i++) {
 for(int j = y_r-3;j < y_r;j++) {
 if(POB[i][j].IsExist) {
 int val = POB[i][j].val;
 if(set_tmp.find(val) != set_tmp.end())
 set_tmp.insert(val);
 }
 }
 }
 if(set_tmp.size() == 9)return false;
 set<int>::iterator it;
 for(int i = 1;i <= 9;i++) {
 if(set_tmp.find(i) == set_tmp.end())POB[x][y].set_p.insert(i);
 }
 if(POB[x][y].set_p.size() <= 0)return false;
 return true;
 }
 void Move(int step) {
 if(step >= index) {
 result = true;
 return;
 }
 else {
 if(result == true)return;
 int pi = x[step];
 int pj = y[step];
 set<int>::iterator it;
 for(it = POB[pi][pj].set_p.begin();it != POB[pi][pj].set_p.end();it++) {
 if(result == true)return;
 int val = (int)(*it);
 POB[pi][pj].val = val;
 int xtmp[81];
 int ytmp[81];
 int indextmp = 0;
 for(int i = step+1;i < index;i++) {
 int xi = x[i];
 int yi = y[i];
 if(xi == pi || yi == pj || GetRegionOfBoard(xi,yi) == GetRegionOfBoard(pi,pj)) {
 if(POB[xi][yi].set_p.find(val) != POB[xi][yi].set_p.end()) {
 xtmp[indextmp] = xi;
 ytmp[indextmp++] = yi;
 POB[xi][yi].set_p.erase(val);
 }
 }
 }
 Move(step+1);
 for(int i = 0;i < indextmp;i++) {
 int xi = xtmp[i];
 int yi = ytmp[i];
 POB[xi][yi].set_p.insert(val);
 }
 POB[pi][pj].val = -1;
 }
 }
 }
 bool isValidSudoku(vector<vector<char>> &board) {
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(board[i][j] == '.') {
 POB[i][j].IsExist = false;
 }
 else {
 POB[i][j].IsExist = true;
 POB[i][j].val = board[i][j] - '0';
 }
 }
 }
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(POB[i][j].IsExist == false) {
 if(GetSetOfPOB(i,j) == false)return false;
 }
 }
 }
 index = 0;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(POB[i][j].IsExist == false) {
 x[index] = i;
 y[index++] = j;
 }
 }
 }
 result = false;
 Move(0);
 return result;
 }
};

后来看网上牛人的代码，用int二进制来存，我又写了一版：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150


struct Pointxy {
 int x;
 int y;
 int val;
};
int cmp(Pointxy a,Pointxy b) {
 return a.val < b.val;
}
class Solution {
public:
 int bitarray[9];
 int map[9][9];
 bool result;
 int CountOnes(int v)
 {
 int number = 0;
 while(v)
 {
 v &= (v-1);
 number++;
 }
 return number;
 }
 int GetRegionOfBoard(int x,int y) {
 if(x>= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool RefeshMap(int x,int y){
 int set_tmp = 0;
 for(int i = 0;i < 9;i++) {
 if(CountOnes(map[x][i]) == 1) {
 set_tmp = set_tmp | map[x][i];
 }
 if(CountOnes(map[i][y]) == 1) {
 set_tmp = set_tmp | map[x][i];
 }
 }
 int region = GetRegionOfBoard(x,y);
 int x_r = (region / 3 + 1)*3;
 int y_r = (region % 3 + 1)*3;
 for(int i = x_r-3;i < x_r;i++) {
 for(int j = y_r-3;j < y_r;j++) {
 if(CountOnes(map[i][j]) == 1) {
 set_tmp = set_tmp | map[i][j];
 }
 }
 }
 if(set_tmp == 511)return false;
 map[x][y] = 511 - set_tmp;
 return true;
 }
 void Move(Pointxy pxy[81],int index) {
 if(result == true)return;
 if(index <= 0) {
 result = true;
 return;
 }
 else {
 sort(pxy,pxy+index,cmp);
 int pi = pxy[0].x;
 int pj = pxy[0].y;
 for(int ibit = 0;ibit < 9;ibit++) {
 if(result == true)return;
 if(map[pi][pj] & bitarray[ibit]) {
 map[pi][pj] -= bitarray[ibit];
 int xtmp[81];
 int ytmp[81];
 int indextmp = 0;
 for(int i = 1;i < index;i++) {
 int xi = pxy[i].x;
 int yi = pxy[i].y;
 if(xi == pi || yi == pj || GetRegionOfBoard(xi,yi) == GetRegionOfBoard(pi,pj)) {
 if(map[xi][yi] & bitarray[ibit]) {
 xtmp[indextmp] = xi;
 ytmp[indextmp++] = yi;
 map[xi][yi] -= bitarray[ibit];
 }
 }
 }
 Pointxy pxyt[81];
 int indext = 0;
 for(int i = 1;i < index;i++) {
 pxyt[indext].x = pxy[i].x;
 pxyt[indext].y = pxy[i].y;
 pxyt[indext++].val = CountOnes(map[pxyt[indext].x][pxyt[indext].y]);
 }
 Move(pxyt,indext);
 for(int i = 0;i < indextmp;i++) {
 int xi = xtmp[i];
 int yi = ytmp[i];
 map[xi][yi] += bitarray[ibit];
 }
 map[pi][pj] += bitarray[ibit];
 }
 }
 }
 }
 bool isValidSudoku(vector<vector<char>> &board) {
 for(int i = 0;i < 9;i++) {
 bitarray[i] = (int)pow(2.0,i);
 }
 int count = 0;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(board[i][j] == '.') {
 map[i][j] = 511;
 }
 else {
 map[i][j] = bitarray[board[i][j] - '0'-1];
 count++;
 }
 }
 }
 if(count < 17)return false;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(map[i][j] == 511) {
 if(RefeshMap(i,j) == false)return false;
 }
 }
 }
 Pointxy pxy[81];
 int index = 0;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(CountOnes(map[i][j]) != 1) {
 pxy[index].x = i;
 pxy[index].y = j;
 pxy[index].val = CountOnes(map[i][j]);
 }
 }
 }
 result = false;
 Move(pxy,index);
 return result;
}
};

WA???不科学啊？？？
最后WA在一个我一看就无可行解的情况。
实在没办法，查别人的代码。我擦，原来题目要求判断该数独是否是一个当前状态下满足条件的数独，问题简单了好多好多好多啊~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


class Solution {
public:
 int bitarray[9];
 int map[9][9];
 bool result;
 int GetRegionOfBoard(int x,int y) {
 if(x>= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool CheckRows() {
 for(int i = 0;i < 9;i++) {
 int tmp = 0;
 for(int j = 0;j < 9;j++) {
 if(tmp & map[i][j])return false;
 tmp |= map[i][j];
 }
 }
 return true;
 }
 bool CheckCols() {
 for(int j = 0;j < 9;j++) {
 int tmp = 0;
 for(int i = 0;i < 9;i++) {
 if(tmp & map[i][j])return false;
 tmp |= map[i][j];
 }
 }
 return true;
}
bool CheckRegion() {
 for(int region = 0;region < 9;region++) {
 int x_r = (region / 3 + 1)*3;
 int y_r = (region % 3 + 1)*3;
 int tmp = 0;
 for(int i = x_r-3;i < x_r;i++) {
 for(int j = y_r-3;j < y_r;j++) {
 if(tmp & map[i][j])return false;
 tmp = tmp | map[i][j];
 }
 }
 }
 return true;
}
bool isValidSudoku(vector<vector<char>> &board) {
 for(int i = 0;i < 9;i++) {
 bitarray[i] = (int)pow(2.0,i);
 }
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(board[i][j] == '.') {
 map[i][j] = 0;
 }
 else {
 map[i][j] = bitarray[board[i][j] - '0'-1];
 }
 }
 }
 return CheckRows() && CheckCols() && CheckRegion();
}
};

[leetcode_92]Reverse Linked List II

Fri, 22 May 2015 11:57:25 +0000

输入一个单向链表，要求将链表从m到n 逆序。不要开辟额外的空间。
开始题意读错了，以为将m和n两个节点交换位置。结果WA
但是后来一向，这个可以算是逆序的一个步骤，所以代码稍微改了改就AC了，其中额外注意m=1 n-m=1的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


class Solution {
public:
 ListNode *reverseBetween(ListNode *head, int m, int n) {
 int length = GetLengthListNode(head);
 if(length <= 0 || m >= n || length < n) return head;
 while(m < n) {
 head = reverseBetweenStep(head,m,n);
 m++;
 n--;
 }
 return head;
 }
private:
 ListNode *reverseBetweenStep(ListNode *head, int m, int n) {
 if(n-m == 1) {
 if(m == 1) {
 ListNode * mlistNode = head;
 ListNode * nlistNode = GetListNodeFromPos(head,n);
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode;
 mlistNode->next = ntmpnext;
 return nlistNode;
 }
 else {
 ListNode * beforem = GetListNodeFromPos(head,m-1);
 ListNode * mlistNode = GetListNodeFromPos(head,m);
 ListNode * nlistNode = GetListNodeFromPos(head,n);
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode;
 mlistNode->next = ntmpnext;
 beforem->next = nlistNode;
 return head;<br />
 }
 }
 if(m == 1) {
 ListNode * mlistNode = head;
 ListNode * beforen = GetListNodeFromPos(head,n-1);
 ListNode * nlistNode = GetListNodeFromPos(head,n);
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode->next;
 mlistNode->next = ntmpnext;
 beforen->next = mlistNode;
 return nlistNode;
 }
 else {
 ListNode * beforem = GetListNodeFromPos(head,m-1);
 ListNode * mlistNode = GetListNodeFromPos(head,m);
 ListNode * beforen = GetListNodeFromPos(head,n-1);
 ListNode * nlistNode = GetListNodeFromPos(head,n);

 ListNode * mtmpnext = mlistNode->next;
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode->next;
 mlistNode->next = ntmpnext;
 beforen->next = mlistNode;
 beforem->next = nlistNode;
 return head;
 }
 }
};
ListNode * GetListNodeFromPos(ListNode *head,int pos) {
 pos--;
 while(pos--) {
 head = head->next;
 }
 return head;
}
int GetLengthListNode(ListNode *listNode) {
 int Length = 0;
 while(listNode != NULL) {
 listNode = listNode->next;
 Length++;
 }
 return Length;
};

[leetcode_67]Add Binary

Fri, 22 May 2015 11:56:02 +0000

90个题了，真心不容易。
两个字符串的二进制加法。找一个int来存储进位。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 string addBinary(string a, string b) {
 string ans = "";
 int lenMin = a.length() < b.length()?a.length():b.length();
 int inbit = 0;
 for(int i = 0;i < lenMin;i++) {
 int aVal = a[a.length()-1-i] - '0';
 int bVal = b[b.length()-1-i] - '0';
 int sum = inbit + aVal + bVal;
 inbit = sum / 2;
 ans.push_back(sum%2 + '0');
 }
 if(a.length() > b.length()) {
 for(int i = lenMin;i < a.length();i++) {
 int Val = a[a.length()-1-i] - '0' + inbit;
 inbit = Val / 2;
 ans.push_back(Val%2 + '0');
 }
 }
 else {
 for(int i = lenMin;i < b.length();i++) {
 int Val = b[b.length()-1-i] - '0' + inbit;
 inbit = Val / 2;
 ans.push_back(Val%2 + '0');
 }
 }
 if(inbit != 0) {
 ans.push_back(inbit + '0');
 }
 string ansr(ans.rbegin(),ans.rend());
 return ansr;
 }
};

[leetcode_31]Next Permutation

Fri, 22 May 2015 11:54:52 +0000

给定一个数组，求该数的序列的下一个序列。如果该序列已经是最后一个最大的序列了，输出最小的排序。
首先思路一定要清晰。

要找第一个值得交换的数——该数尽可能的靠近个位，且该数的前面存在一个数比该数大。然后找到前面那个比该数大的最小的数交换即可。
最后~该数前面的所有数升序排序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 void nextPermutation(vector<int> &num) {
 bool IsSwap = false;
 for(int i = num.size()-1;i >= 0;i--) {
 int index = -1;
 int max = 0xffff;
 for(int j = i+1;j < num.size();j++) {
 if(num[j] > num[i] && num[j] < max) {
 index = j;
 max = num[j];
 IsSwap = true;
 }
 }
 if(IsSwap) {
 int tmp = num[index];
 num[index] = num[i];
 num[i] = tmp;
 sort(num.begin()+i+1,num.end(),cmp);
 break;
 }
 }
 if(IsSwap == false) {
 sort(num.begin(),num.end(),cmp);
 }
 }
};

[leetcode_147]Insertion Sort List

Fri, 22 May 2015 11:52:49 +0000

单向链表的插入排序，本来很简单的题，写得跟屎一样。是不是应该歇歇暂时不写leetcode了。明天就开题了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 int GetCount(ListNode *head) {
 int count = 0;
 while(head != NULL) {
 count++;
 head=head->next;
 }
 return count;
 }
 ListNode *insertionSortList(ListNode *head) {
 if(head == NULL)return head;
 ListNode * now = head->next;
 ListNode * before = head;
 int count = GetCount(head);
 while(now != NULL) {
 ListNode * tmpnow = now->next;
 if(now->val <= head->val) {
 ListNode * tmp = now->next;
 before->next = now->next;
 now->next = head;
 head = now;
 now = tmpnow;
 }
 else {
 ListNode * beforetmp = head;
 ListNode * tmp = beforetmp->next;
 while(tmp != now && tmp->val <= now->val) {
 beforetmp = beforetmp->next;
 tmp = tmp->next;
 }
 if(tmp != now) {
 beforetmp->next = now;
 before->next = now->next;
 now->next = tmp;
 now = tmpnow;
 }
 else {
 before = now;
 now = tmpnow;
 }
 }
 }
 ListNode * chead = head;
 for(int i = 1;i < count;i++) {
 chead = chead->next;
 }
 chead->next = NULL;
 return head;
 }
};

[leetcode_98] Validate Binary Search Tree

Fri, 22 May 2015 11:51:21 +0000

判断一二叉棵树是否为BST。
结合BST的特征一直递归着找就行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 bool result;
 enum Flag {left, right, leftright};
 void isValidBSTStep(TreeNode * root, int val1, int val2, Flag flag) {
 switch(flag){
 case left:
 if(root->val <= val1) {
 result = false;
 return;
 }
 break;
 case right:
 if(root->val >= val2) {
 result = false;
 return;
 }
 break;
 case leftright:
 if(root->val <= val1 || root->val >= val2) {
 result = false;
 return;
 }
 break;
 }
 if(root->left != NULL) {
 if(flag == left || flag == leftright)
 isValidBSTStep(root->left, val1, root->val, leftright);
 else
 isValidBSTStep(root->left, 0, root->val, right);
 }
 if(root->right != NULL ){
 if(flag == right || flag == leftright)
 isValidBSTStep(root->right, root->val, val2, leftright);
 else
 isValidBSTStep(root->right, root->val, 0, left);
 }
 }
 bool isValidBST(TreeNode *root) {
 result = true;
 if(root == NULL) return result;
 if(root->left != NULL) {
 isValidBSTStep(root->left, 0, root->val, right);
 }
 if(root->right != NULL ){
 isValidBSTStep(root->right, root->val, 0, left);
 }
 return result;
 }
};

[leetcode_39]Combination Sum

Fri, 22 May 2015 11:49:33 +0000

无穷背包？
输入2 3 6 7
输出2 3 6 7所有能构成7的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


int cmp(int a,int b) {
 return a < b;
}
struct ValNode {
 ValNode():IsExist(false){set_v.clear();}
 vector<vector<int>>set_v;
 bool IsExist;
};
class Solution {
public:
 bool CheckIsExist(vector<int>&item_tmp,vector<vector<int>>&set_v) {
 sort(item_tmp.begin(),item_tmp.end(),cmp);
 for(int i = 0;i < set_v.size();i++) {
 if(item_tmp == set_v[i])return true;
 }
 return false;
 }
 vector<vector<int>> combinationSum(vector<int> &candidates, int target) {
 int max = target;
 ValNode *valnodes = new ValNode[max+1];
 valnodes[0].IsExist = true;
 vector<int>item;
 item.clear();
 valnodes[0].set_v.push_back(item);
 for(int i = 0;i <= target;i++) {
 if(valnodes[i].IsExist) {
 for(int j = 0;j < candidates.size();j++) {
 if(i + candidates[j] <= target) {
 valnodes[i+candidates[j]].IsExist = true;
 for(int k = 0;k < valnodes[i].set_v.size();k++) {
 vector<int>item_tmp;
 item_tmp.clear();
 item_tmp = valnodes[i].set_v[k];
 item_tmp.push_back(candidates[j]);
 if(!CheckIsExist(item_tmp,valnodes[i+candidates[j]].set_v))
 valnodes[i+candidates[j]].set_v.push_back(item_tmp);
 }
 }
 }
 }
 }
 return valnodes[max].set_v;
 }
};

[leetcode_95]Unique Binary Search Trees II

Fri, 22 May 2015 11:47:39 +0000

输入n，获得1-n生成的所有BTS

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Solution {
public:
 vector<TreeNode *> genTreeNodes(int left,int right) {
 vector<TreeNode *> nodes;
 nodes.clear();
 if(left > right) {
 nodes.push_back(NULL);
 return nodes;
 }
 if(left == right) {
 TreeNode * node = new TreeNode(left);
 nodes.push_back(node);
 return nodes;
 }
 for(int i = left;i<= right;i++) {
 vector<TreeNode *>lefts,rights;
 lefts.clear();
 rights.clear();
 lefts = genTreeNodes(left,i-1);
 rights = genTreeNodes(i+1,right);
 // 交替枚举left and right
 for(int l = 0;l < lefts.size();l++) {
 for(int r = 0; r < rights.size();r++) {
 TreeNode *node = new TreeNode(i);
 node->left = lefts[l];
 node->right = rights[r];
 nodes.push_back(node);
 }
 }
 }
 return nodes;
 }
 vector<TreeNode *> generateTrees(int n) {
 vector<TreeNode *>nodes;
 nodes.clear();
 nodes = genTreeNodes(1,n);
 return nodes;
 }
};

[leetcode_50]Pow(x, n)

Fri, 22 May 2015 11:46:03 +0000

模拟pow，注意超时和n为负数的情况。
可以二分下去这样复杂度为log(n)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class Solution {
public:
 double powstep(double x,int n) {
 if(n == 0)return 1.0;
 if(n == 1)return x;
 if(n == 2)return x*x;
 if(n % 2 == 0) {
 return powstep(powstep(x,n/2),2);
 }
 else {
 return x * powstep(powstep(x,n/2),2);
 }
 }
 double pow(double x, int n) {
 int flag = 1;
 if(n < 0)
 flag = -1;
 n = (-1)*n;
 double ans = powstep(x,n);
 if(flag == -1)
 ans = 1.0 / ans;
 return ans;
 }
};

[leetcode_86]Partition List

Fri, 22 May 2015 11:44:30 +0000

单链表划分。选择一个 val x 然后单链表中比 x 值小的节点在前，大的在后，但是小与小，大与大之间保持原位置。
想法：
先找到第一个比 x 小的值，放到最前面。
再找到第一个比 x 大的值。
接下来就是从 x 大的值的节点后面开始枚举，大的继续，出现小的，交换到第一个比 x 大的值前面。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


class Solution {
public:
 ListNode *partition(ListNode *head, int x) {
 if(head == NULL || head->next == NULL)
 return head;
 ListNode * beforenode;
 ListNode * minnode, *maxnode; // find the 1st minnode
 if(head->val < x) {
 minnode = head;
 }
 else {
 beforenode = head;
 minnode = head->next;
 while(minnode != NULL && minnode->val >= x) {
 beforenode = minnode;
 minnode = minnode->next;
 }
 if(minnode == NULL) return head;
 beforenode->next = minnode->next;
 minnode->next = head; // now the head is minnode;
 }
 beforenode = minnode;
 maxnode = minnode->next;
 while(maxnode != NULL && maxnode->val < x) {
 beforenode = maxnode;
 maxnode = maxnode->next;
 }
 if(maxnode == NULL || maxnode->next == NULL) return minnode;
 // now find minnode and maxnode. the head is minnode
 head = minnode;
 ListNode * now = maxnode->next;
 while(now != NULL) {
 if(now->val >= x) {
 maxnode = now;
 now = now->next;
 }
 else {
 ListNode * tmp = beforenode->next;
 maxnode->next = now->next;
 beforenode->next = now;
 now->next = tmp;
 now = maxnode->next;
 beforenode = beforenode->next;
 }
 }
 return head;
 }
};

[leetcode_103]Binary Tree Zigzag Level Order Traversal

Fri, 22 May 2015 11:43:17 +0000

序列化二叉树，但是行输出时从左到右从右到左交替进行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 enum Direciton {left,right};
 vector<vector<int>> zigzagLevelOrder(TreeNode *root) {
 vector<vector<int>> result;
 result.clear();
 vector<TreeNode*> seq,seq_c;
 seq.clear();
 if(root != NULL)seq.push_back(root);
 Direciton direction = left;
 while(seq.size() > 0) {
 seq_c.clear();
 vector<int>item;
 item.clear();
 if(direction == left) {
 direction = right;
 for(int i = 0; i < seq.size();i++) {
 item.push_back(seq[i]->val);
 if(seq[i]->left != NULL) {
 seq_c.push_back(seq[i]->left);
 }
 if(seq[i]->right != NULL) {
 seq_c.push_back(seq[i]->right);
 }
 }
 }
 else {
 direction = left;
 for(int i = seq.size()-1; i >= 0; i--) {
 item.push_back(seq[i]->val);
 }
 for(int i = 0; i < seq.size();i++) {
 if(seq[i]->left != NULL) {
 seq_c.push_back(seq[i]->left);
 }
 if(seq[i]->right != NULL) {
 seq_c.push_back(seq[i]->right);
 }
 }
 }
 result.push_back(item);
 seq = seq_c;
 }
 return result;
 }
};

[leetcode_114]Flatten Binary Tree to Linked List

Fri, 22 May 2015 11:42:05 +0000

将一个二叉树扁平化。
所有扁平化就是：

变为：

Each node’s right child points to the next node of a pre-order traversal.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
public:
 TreeNode * flattenStep(TreeNode *root) {
 if(root-&gt;left == NULL &amp;&amp; root-&gt;right == NULL)
 return root;
 TreeNode * tmp = NULL;
 if(root-&gt;right != NULL)
 tmp = flattenStep(root-&gt;right);
 if(root-&gt;left != NULL)
 root-&gt;right = flattenStep(root-&gt;left);
 else
 root-&gt;right = NULL;
 root-&gt;left = NULL;
 if(tmp != NULL) {
 TreeNode * tmpright = root;
 while(tmpright-&gt;right != NULL)
 tmpright = tmpright-&gt;right;
 tmpright-&gt;right = tmp;
 }
 return root;
 }
 void flatten(TreeNode *root) {
 if(root == NULL)return;
 root = flattenStep(root);
 }
};

[leetcode_51]N-Queens

Fri, 22 May 2015 11:40:54 +0000

八皇后问题，输出各解决方案。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


class Solution {
public:
 int count;
 int *x;
 int *y;
 int index;
 bool *rows, *cols, *ltrb, *rtlb;
 vector<vector<string>> ans;
 vector<string> item;
 void SetFalse(bool *arrayin, int n) {
 for(int i = 0; i < n; i++)
 arrayin[i] = false;
 }
 void Move(int row, int n) {
 for(int col = 0; col < n; col++) {
 if( rows[row] != true &&
 cols[col] != true &&
 ltrb[row+col] != true &&
 rtlb[n-1+row-col] != true) {
 if(row == n-1) {
 x[index] = row;
 y[index++] = col;
 item.clear();
 string subitem = "";
 for(int j = 0; j < n; j++) {
 subitem.push_back('.');
 }
 for(int i = 0; i < n; i++) {
 item.push_back(subitem);
 }
 for(int i = 0; i < index; i++) {
 item[x[i]][y[i]] = 'Q';
 }
 ans.push_back(item);
 index--;
 }
 else {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 x[index] = row;
 y[index++] = col;
 Move(row+1, n);
 index--;
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 }
 }
 }
 vector<vector<string>> solveNQueens(int n) {
 x = new int[n];
 y = new int[n];
 rows = new bool[n];
 SetFalse(rows, n);
 cols = new bool[n];
 SetFalse(cols, n);
 ltrb = new bool[n+n-1];
 SetFalse(ltrb, n+n-1);
 rtlb = new bool[n+n-1];
 SetFalse(rtlb, n+n-1);
 ans.clear();
 if(n == 1) {
 string subitem = "Q";
 vector<string> item;
 item.clear();
 item.push_back(subitem);
 ans.push_back(item);
 return ans;
 }
 int row = 0;
 index = 0;
 for(int col = 0; col < n; col++) {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 x[index] = row;
 y[index++] = col;
 Move(row+1, n);
 index--;
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 return ans;
 }
};

[leetcode_52]N-Queens II

Fri, 22 May 2015 11:39:37 +0000

八皇后问题，输出解法数量即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


class Solution {
public:
 int count;
 bool *rows,*cols,*ltrb,*rtlb;
 void SetFalse(bool *arrayin,int n) {
 for(int i = 0;i < n;i++)
 arrayin[i] = false;
 }
 void Move(int row,int n) {
 for(int col = 0;col < n;col++) {
 if( rows[row] != true &&
 cols[col] != true &&
 ltrb[row+col] != true&&
 rtlb[n-1+row-col] != true) {
 if(row == n-1)count++;
 else {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 Move(row+1,n);
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 }
 }
 }
 int totalNQueens(int n) {
 rows = new bool[n];//行
 SetFalse(rows,n);
 cols = new bool[n];//列
 SetFalse(cols,n);
 ltrb = new bool[n+n-1];
 SetFalse(ltrb,n+n-1);
 rtlb = new bool[n+n-1];
 SetFalse(rtlb,n+n-1);
 count = 0;
 if(n == 1)return 1;
 int row = 0;
 for(int col = 0;col < n;col++) {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 Move(row+1,n);
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 return count;
 }
};

[leetcode_128] Longest Consecutive Sequence

Fri, 22 May 2015 11:29:11 +0000

乱序的情况下，找最长连续子序列。
说实话，这个题我确实没在O(n)的复杂度下做出来。
看了别人的代码才恍然大悟。
不过之前有想到用hash不过我记得STL的map是O(logn)的查找复杂度，所以最终的复杂度是O(nlogn)当时就放弃了。
今天好好的了解了下什么是散列表, map, set, hash_map, hash_set有什么区别。感觉还是很有帮助的。
也了解到一个叫boost的准C++标准库。如果大家感兴趣可以自己查查。
这个题的最终解法就是hash+左右扩展模拟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 ListNode * GetListNthNode(ListNode * head, int n) {
 int k = 0;
 while(k < n) {
 k++;
 head = head->next;
 }
 return head;
 }
 int CountList(ListNode *head) {
 int count = -1;
 while(head != NULL) {
 head = head->next;
 count++;
 }
 return count;
 }
 TreeNode *BSearchT(int left, int right, ListNode * head) {
 if(right < left) return NULL;
 int mid = (left + right) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid - left)->val);
 root->left = BSearchT(left, mid - 1, head);
 root->right = BSearchT(mid + 1, right, GetListNthNode(head, mid + 1 - left));
 return root;
 }
 TreeNode *sortedListToBST(ListNode *head) {
 if(head == NULL)
 return NULL;
 int n = CountList(head);
 int mid = (0 + n) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid)->val);
 root->left = BSearchT(0, mid - 1, head);
 root->right = BSearchT(mid + 1, n, GetListNthNode(head, mid + 1));
 return root;
 }
};

[leetcode_109]Convert Sorted List to Binary Search Tree

Fri, 22 May 2015 11:27:51 +0000

这个题是http://blog.sina.com.cn/s/blog_672f71fc0101os5r.html
该题目的变形，只是把数组换成了单链表，在单链表查找的时候注意优化，每次二分之后head节点对于left来说依然是head，但是对right来说head节点要更新为mid的那个节点。不然会超时。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 ListNode * GetListNthNode(ListNode * head, int n) {
 int k = 0;
 while(k < n) {
 k++;
 head = head->next;
 }
 return head;
 }
 int CountList(ListNode *head) {
 int count = -1;
 while(head != NULL) {
 head = head->next;
 count++;
 }
 return count;
 }
 TreeNode *BSearchT(int left, int right, ListNode * head) {
 if(right < left) return NULL;
 int mid = (left + right) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid - left)->val);
 root->left = BSearchT(left, mid - 1, head);
 root->right = BSearchT(mid + 1, right, GetListNthNode(head, mid + 1 - left));
 return root;
 }
 TreeNode *sortedListToBST(ListNode *head) {
 if(head == NULL)
 return NULL;
 int n = CountList(head);
 int mid = (0 + n) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid)->val);
 root->left = BSearchT(0, mid - 1, head);
 root->right = BSearchT(mid + 1, n, GetListNthNode(head, mid + 1));
 return root;
 }
};

[leetcode_38]Count and Say

Fri, 22 May 2015 11:26:08 +0000

模拟题，迭代直到n即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 string SayStep(string str) {
 string strstep = "";
 int index = 0;
 while(index < str.length()) {
 char c = str[index];
 int count_c = 1;
 int i;
 for(i = index+1;i < str.length();i++) {
 if(c == str[i])count_c++;
 else break;
 }
 index = i;
 strstep.push_back(count_c + '0');
 strstep.push_back(c);
 }
 return strstep;
 }
 string countAndSay(int n) {
 string str = "1";
 for(int i = 1; i < n;i++) {
 str = SayStep(str);
 }
 return str;
 }
};

[leetcode_55]Jump Game

Fri, 22 May 2015 11:24:56 +0000

从前往后一个一个标记会超时，后来想了下某些情况下复杂度是o(n^2)
但是从后往前标记，不一样，近似于o(n)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 void FindMin(int A[],int n,bool flag[]) {
 if(n <= 0)return;
 int min = 0xffff;
 for(int i = n-1;i >= 0;i--) {
 if(A[i] + i >= n) {
 flag[i] = true;
 if(min > i)
 min = i;
 }
 }
 if(min == 0xffff || flag[0] == true)return;
 FindMin(A,min,flag);
 }
 bool canJump(int A[], int n) {
 bool * flag = new bool[n+1];
 if(n == 1)return true;
 for(int i = 0;i < n;i++) {
 flag[i] = false;
 }
 FindMin(A,n-1,flag);
 return flag[0];
 }
};

[leetcode_34]Search for a Range

Fri, 22 May 2015 11:23:45 +0000

二分查找的变形，有序数组，允许重复数字，要求查找目标的区间，如果不存在目标，输出[-1,-1]。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 void bSearch(int A[],int left,int right,int target,int flag,int &val) {
 if(left > right) return;
 int mid = (left + right) / 2;
 if(A[mid] == target) {
 val = mid;
 if(flag == 0) {
 bSearch(A, left, mid-1, target, flag, val);
 } else {
 bSearch(A, mid+1, right, target, flag, val);
 }
 } else {
 if(A[mid] < target) {
 bSearch(A, mid+1, right, target, flag, val);
 } else {
 bSearch(A, left, mid-1, target, flag, val);
 }
 }
 }

 vector<int> searchRange(int A[], int n, int target) {
 vector<int> ans;
 ans.clear();
 int left = -1;
 int right = -1;
 bSearch(A, 0, n-1, target, 0, left);
 bSearch(A, 0, n-1, target, 1, right);
 ans.push_back(left);
 ans.push_back(right);
 return ans;
 }
};

[leetcode_90]Subsets II

Fri, 22 May 2015 02:05:45 +0000

http://blog.sina.com.cn/s/blog_672f71fc0101phtr.html 该题的变形。
允许重复数字，但是求得的子集中要去除重复子集。
开始超时，后来稍微优化了下，需要检验目前找到的子集中是否有当前需要插入的子集，从后往前，发现size不一样就可以停下了。
当然想的如果还超时就用map

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 bool CheckIn(vector<int> item1,vector<int> item2) {
 if(item1.size() != item2.size())return false;
 for(int i = 0;i < item1.size();i++) {
 if(item1[i] != item2[i])return false;
 }
 return true;
 }
 void AddItemStep(int i,int k,vector<int>&S,vector<vector<int>>&ans,vector<int>&item) {
 if(item.size() == k) {
 for(int i = ans.size()-1;i >= 0&&item.size() == ans[i].size();i--) {
 if(CheckIn(item,ans[i]) == true)return;
 }
 ans.push_back(item);
 return;
 }
 else {
 if(i >= S.size())return;
 item.push_back(S[i]);
 AddItemStep(i+1,k,S,ans,item);
 item.pop_back();
 AddItemStep(i+1,k,S,ans,item);
 }
 }
 void AddItem(int k,vector<int> &S,vector<vector<int>>&ans) {
 int i = 0;
 vector<int> item;
 item.clear();
 AddItemStep(i,k,S,ans,item);
 }
 vector<vector<int>> subsetsWithDup(vector<int> &S) {
 sort(S.begin(),S.end(),cmp);
 vector<vector<int>>ans;
 ans.clear();
 vector<int>item;
 item.clear();
 ans.push_back(item);
 for(int i = 1;i <= S.size();i++) {
 AddItem(i,S,ans);
 }
 return ans;
 }
};

[leetcode_63]Unique Paths II

Fri, 22 May 2015 02:04:32 +0000

Unique Paths
http://blog.sina.com.cn/s/blog_672f71fc0101pf1c.html 的变形。加入障碍物，判断一下即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70


struct PPoint
{
 int x;
 int y;
};
class Solution {
public:
 bool CheckIn(int x,int y,PPoint *p,int top)
 {
 for(int i = 0;i < top;i++)
 {
 if(x == p[i].x && y == p[i].y)
 {
 return true;
 }
 }
 return false;
 }
 int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
 int m = obstacleGrid.size();
 if(m <= 0 )return 0;
 int n = obstacleGrid[0].size();
 if(obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1)return 0;
 for(int i = 0;i < m;i++)
 for(int j = 0;j < n;j++)
 if(obstacleGrid[i][j] == 1)obstacleGrid[i][j] = -1;
 PPoint *p = new PPoint[m+n];
 PPoint *p_c = new PPoint[m+n];
 int index = 0;
 p[index].x = 0;
 p[index++].y = 0;
 obstacleGrid[0][0] = 1;
 while(true)
 {
 int top = 0;
 for(int i = 0;i < index;i++)
 {
 int x = p[i].x;
 int y = p[i].y;
 if(x + 1 < m && obstacleGrid[x+1][y] != -1)
 {
 obstacleGrid[x+1][y] += obstacleGrid[x][y];
 if(CheckIn(x+1,y,p_c,top) == false)
 {
 p_c[top].x = x+1;
 p_c[top++].y = y;
 }
 }
 if(y + 1 < n && obstacleGrid[x][y+1] != -1)
 {
 obstacleGrid[x][y+1] += obstacleGrid[x][y];
 if(CheckIn(x,y+1,p_c,top) == false)
 {
 p_c[top].x = x;
 p_c[top++].y = y+1;
 }
 }
 }
 if(top == 0)
 break;
 index = top;
 for(int i = 0;i < top;i++)
 {
 p[i].x = p_c[i].x;
 p[i].y = p_c[i].y;
 }
 }
 return obstacleGrid[m-1][n-1];
 }
};

[leetcode_14]Longest Common Prefix

Fri, 22 May 2015 01:58:14 +0000

给定一些字符串，求这些字符串的最长公共前缀。
一个一个比就行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class Solution {
public:
 bool EqualAll(vector<string>& strs, int k) {
 for(int i = 1; i < strs.size(); i++) {
 if(strs[i][k] != strs[0][k]) return false;
 }
 return true;
 }
 string longestCommonPrefix(vector<string>& strs) {
 string ans = "";
 if(strs.size() <= 0) return ans;
 int len = 0xffff;
 for(int i = 0; i < strs.size(); i++) {
 if(strs[i].size() < len) len = strs[i].size();
 }
 for(int i = 0; i < len; i++) {
 if(EqualAll(strs, i))
 ans.push_back(strs[0][i]);
 else
 return ans;
 }
 return ans;
 }
};

[leetcode_113]Path Sum II

Fri, 22 May 2015 01:56:30 +0000

给一个二叉树 root 和一个 target 值，求所有从根开始到叶节点的路径和等于 target 的路径。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


class Solution {
public:
 void MoveOnPath(TreeNode *node,int sum,int &val,vector<int>&item,vector<vector<int>>&ans) {
 if(node == NULL) return;
 if(node->left == NULL && node->right == NULL) {
 if(sum == val) ans.push_back(item);
 return;
 }
 if(node->left != NULL) {
 val += node->left->val;
 item.push_back(node->left->val);
 MoveOnPath(node->left, sum, val, item, ans);
 val -= node->left->val;
 item.pop_back();
 }
 if(node->right != NULL) {
 val += node->right->val;
 item.push_back(node->right->val);
 MoveOnPath(node->right, sum, val, item, ans);
 val -= node->right->val;
 item.pop_back();
 }
 }
 vector<vector<int>> pathSum(TreeNode *root, int sum) {
 vector<vector<int>> ans;
 ans.clear();
 if(root == NULL) return ans;
 int val = 0;
 vector<int> item;
 item.clear();
 val += root->val;
 item.push_back(root->val);
 MoveOnPath(root, sum, val, item, ans);
 return ans;
 }
};

[leetcode_78]Subsets

Fri, 22 May 2015 01:55:18 +0000

给定一个数组，比如{1,2,3,4} 求出该集合的所有子集。
其中WA一次，因为要求升序排列。
搜索即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 void AddItemStep(int i,int k,vector<int>&S,vector<vector<int>>&ans,vector<int>&item) {
 if(item.size() == k) {
 ans.push_back(item);
 return;
 }
 else {
 if(i >= S.size())return;
 item.push_back(S[i]);
 AddItemStep(i+1,k,S,ans,item);
 item.pop_back();
 AddItemStep(i+1,k,S,ans,item);
 }
 }
 void AddItem(int k,vector<int> &S,vector<vector<int>>&ans) {
 int i = 0;
 vector<int> item;
 item.clear();
 AddItemStep(i,k,S,ans,item);
 }
 vector<vector<int>> subsets(vector<int> &S) {
 sort(S.begin(),S.end(),cmp);
 vector<vector<int>>ans;
 ans.clear();
 vector<int>item;
 item.clear();
 ans.push_back(item);
 for(int i = 1;i <= S.size();i++) {
 AddItem(i,S,ans);
 }
 return ans;
 }
};

[leetcode_58]Length of Last Word

Fri, 22 May 2015 01:54:03 +0000

输入一个字符串s，s由空格和字母构成，求最后一个单词的长度。单词定义为仅有字母构成。

class Solution {
public:
int lengthOfLastWord(const char *s) {
int length = strlen(s);
int index = length - 1;
while(s[index] == ' ')index--;
int ans = 0;
for(int i = index;i >= 0&&s[i] != ' ';i--)
ans++;
return ans;
}
};

[leetcode_16]3Sum Closest

Fri, 22 May 2015 01:52:59 +0000

给定一个 array，和一个 target，要求求 array 中三个数之和与 target 最接近。保证唯一解。
直接暴力会超时。
可以排序，两层暴力，然后第三层用二分。就不会超时了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 int bSearch(int tmp,int left,vector<int>&num,int right) {
 if(right - left <= 1) {
 if(abs(tmp - num[left]) < abs(tmp - num[right])) {
 return num[left];
 }
 else {
 return num[right];
 }
 }
 int mid = (left + right) / 2;
 if(num[mid] == tmp)return tmp;
 else
 if(num[mid] > tmp) {
 return bSearch(tmp,left,num,mid-1);
 }
 else {
 return bSearch(tmp,mid+1,num,right);
 }
 }
 int threeSumClosest(vector<int> &num, int target) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int sum = 0;
 int dis = 0xffff;
 sort(num.begin(),num.end(),cmp);
 for(int i = 0;i < num.size()-2;i++) {
 for(int j = i+1;j < num.size()-1;j++) {
 int tmp = num[i] + num[j];
 tmp += bSearch(target-tmp,j+1,num,num.size()-1);
 if(abs(tmp-target) < dis) {
 sum = tmp;
 dis = abs(tmp-target);
 }
 }
 }
 return sum;
 }
};

[leetcode_42] Trapping Rain Water

Fri, 22 May 2015 01:51:54 +0000

根据题目要求，求出灌入水的多少。
先找出某段中的比两边界较小值要大的最大值。如果存在该值，将问题拆分为左+最大值的index和最大值的index+右。
如果不存在该最大值，表示两个边界都比中间的大，灌水求和即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 int sum;
 void WaterStep(int A[],int left,int right) {
 int min = A[left] > A[right] ? A[right] : A[left];
 int max = min;
 int index = -1;
 for(int i = left+1; i < right; i++) {
 if(A[i] > max) {
 index = i;
 max = A[i];
 }
 }
 if(index == -1) {
 for(int i = left+1; i < right; i++)
 sum += min - A[i];
 }
 else {
 WaterStep(A, left, index);
 WaterStep(A, index, right);
 }
 }
 int trap(int A[], int n) {
 sum = 0;
 WaterStep(A, 0, n-1);
 return sum;
 }
};

[leetcode_20]Valid Parentheses

Fri, 22 May 2015 01:50:51 +0000

给定一个字符串，里面只有(){}[]这六种字符，判断，是否它们能够匹配。
栈即可解决该问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 bool IsMatch(char left,char right) {
 if(left == '{' && right == '}' ||
 left == '[' && right == ']' ||
 left == '(' && right == ')') {
 return true;
 }
 else
 return false;
 }
 bool isValid(string s) {
 stack<int> sta;
 for(int i = 0;i < s.length();i++) {
 if(sta.size() == 0 || IsMatch(sta.top(),s[i]) == false) {
 sta.push(s[i]);
 }
 else {
 sta.pop();
 }
 }
 if(sta.size() == 0) {
 return true;
 }
 else
 return false;
 }
};

[leetcode_129]Sum Root to Leaf Numbers

Fri, 22 May 2015 01:49:43 +0000

二叉树从根开始每个结点存放一个0~9的数字，计算从根开始到叶节点生成的所有数字之和。从根开始搜索，到一个叶节点，将string转换加到结果里面就行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 int ConvertNumber(string &tmpNumber) {
 int number = 0;
 for(int i = 0;i < tmpNumber.length();i++) {
 number += (tmpNumber[tmpNumber.length() - 1 - i] - '0')*pow(10.0,i);
 }
 return number;
 }
 void AddNextLevel(TreeNode *node,int &sum,string tmpNumber) {
 tmpNumber.push_back(node->val + '0' - 0);
 if(node->left == NULL && node->right == NULL) {
 sum += ConvertNumber(tmpNumber);
 return ;
 }
 if(node->left != NULL) {
 AddNextLevel(node->left,sum,tmpNumber);
 }
 if(node->right != NULL) {
 AddNextLevel(node->right,sum,tmpNumber);
 }
 }
 int sumNumbers(TreeNode *root) {
 int sum = 0;
 if(root == NULL)return sum;
 string tmpNumber = "";
 AddNextLevel(root,sum,tmpNumber);
 return sum;
 }
};

[leetcode_111]Minimum Depth of Binary Tree

Fri, 22 May 2015 01:48:19 +0000

计算二叉树的最短路径，一层一层的算。我用的应该算是搜索加剪枝，但是如果有宽度搜索，或许时间更快，但是需要额外的空间。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 int min;
 void MoveTo(TreeNode *node, int steps) {
 if (node->left == NULL && node->right == NULL) {
 if (steps < min) {
 min = steps;
 }
 return;
 }
 if (node->left != NULL && steps + 1 < min) {
 MoveTo(node->left, steps + 1);
 }
 if (node->right != NULL && steps + 1 < min) {
 MoveTo(node->right, steps + 1);
 }
 }
 int minDepth(TreeNode *root) {
 min = 999999999;
 if (root == NULL)
 return 0;
 MoveTo(root, 1);
 return min;
 }
};

[leetcode_117]Populating Next Right Pointers in Each Node II

Fri, 22 May 2015 01:47:16 +0000

Populating Next Right Pointers in Each Node的变形：

http://blog.sina.com.cn/s/blog_672f71fc0101ohqp.html
但是貌似自己没有使用常数空间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution {
public:
 void connect(TreeLinkNode *root) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int height = -1;
 TreeLinkNode * rootheight = root;
 while(rootheight != NULL)
 {
 height++;
 rootheight = rootheight->left;
 }
 int NumOfNodes = (int)pow(2.0,height+1) - 1;
 TreeLinkNode ** LinkNodeArray = new TreeLinkNode *[1000000];
 int index = 0;
 LinkNodeArray[index++] = root;
 int bottom = 0;
 int top = index;
 while(true)
 {
 if(bottom == top)
 break;
 for(int i = bottom;i < top;i++)
 {
 if(LinkNodeArray[i] == NULL)
 continue;
 if(i == top-1)
 {
 LinkNodeArray[i] ->next = NULL;
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 else
 {
 LinkNodeArray[i] ->next = LinkNodeArray[i+1];
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 }
 bottom = top;
 top = index;
 }
 }
};

[leetcode_81]Search in Rotated Sorted Array II

Fri, 22 May 2015 01:45:49 +0000

leetcode_60题目的变形
原文链接
这次，array允许重复的。我适当改了下代码判断的情况。
仍然是o(logn)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


class Solution {
public:
 bool searchStep(int A[],int target,int left,int right)
 {
 if(left > right)
 return false;
 int mid = (left+right)/2;
 if(A[mid] == target)
 return true;
 else
 if(A[mid] > target)
 {
 if(A[right] > A[left])
 return searchStep(A,target,left,mid-1);
 else
 return searchStep(A,target,left,mid-1) || searchStep(A,target,mid+1,right);
 }
 else
 {
 if(A[right] > A[left])
 return searchStep(A,target,mid+1,right);
 else
 return searchStep(A,target,mid+1,right) || searchStep(A,target,left,mid-1);
 }
 }
 bool search(int A[], int n, int target)
 {
 int left = 0;
 int right = n-1;
 return searchStep(A,target,left,right);
 }
};

[leetcode_33]Search in Rotated Sorted Array

Fri, 22 May 2015 01:44:32 +0000

给定一个sorted 的array但是需要做个调转：比如： 0 1 2 3 4 5 6 7 8 9 某个调转之后：7 8 9 0 1 2 3 4 5 6
输入target，如果array中存在target返回下标，否则，返回-1。
欧克，傻瓜都能想到o(n)的方法，
有没有更快的？o(logn)?二分？二分查找变形一下就行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 int ans;
 void searchStep(int A[],int target,int left,int right)
 {
 if(left > right)
 return;
 int mid = (left+right)/2;
 if(A[mid] == target)
 {
 ans = mid;
 return;
 }
 else
 {
 if(A[mid] > target)
 {
 if(A[right] > A[left])
 {
 searchStep(A,target,left,mid-1);
 }
 else
 {
 searchStep(A,target,left,mid-1);
 searchStep(A,target,mid+1,right);
 }
 }
 else
 {
 if(A[right] > A[left])
 {
 searchStep(A,target,mid+1,right);
 }
 else
 {
 searchStep(A,target,mid+1,right);
 searchStep(A,target,left,mid-1);
 }
 }
 }
 }
 int search(int A[], int n, int target)
 {
 int left = 0;
 int right = n-1;
 ans = -1;
 searchStep(A,target,left,right);
 return ans;
 }
};

[leetcode_77]Combinations

Fri, 22 May 2015 01:43:16 +0000

简单搜索题，但是题目交代不是很清楚，也可能是自己的英文不大好，就是说给n, 全集为1, 2, 3…n。从里面选k个组成子集，列举所有子集。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 void combineStep(int n, int step, int k, vector<int>& item, vector<vector<int>>& ans, int count)
 {
 if(step > n+1)
 return;
 if(count == k)
 {
 ans.push_back(item);
 return ;
 }
 else
 {
 item.push_back(step);
 combineStep(n, step+1, k, item, ans, count+1);
 item.pop_back();
 combineStep(n, step+1, k, item, ans, count);
 }
 }
 vector<vector<int>> combine(int n, int k) {
 vector<vector<int>> ans;
 ans.clear();
 vector<int> item;
 item.clear();
 combineStep(n, 1, k, item, ans, 0);
 return ans;
 }
};

[leetcode_142]Linked List Cycle II

Fri, 22 May 2015 01:42:11 +0000

判断一个链表中是否有环，并且输出进入环中的节点。如果没有，输出NULL。
判断一个链表是否成环，且不开辟额外的空间，在之前的博客中一提到：
http://blog.sina.com.cn/s/blog_672f71fc0101odsf.html
如何输出环中节点的入口节点？
如果能计算出环中节点个数k，再根据从后向前删除节点的思路：
http://blog.sina.com.cn/s/blog_672f71fc0101pfx6.html
此题可解。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


class Solution {
public:
 ListNode *detectCycle(ListNode *head) {
 if(head == NULL)
 return NULL;
 ListNode * p1 = head;
 ListNode * p2 = head->next;
 if(p2 == NULL)
 return NULL;
 p2 = head->next;
 while(true)
 {
 if(p2 == NULL)
 {
 return NULL;
 }
 else
 if(p1 == p2)
 {
 break;
 }
 else
 {
 p1 = p1->next;
 p2 = p2->next;
 if(p2 == NULL)return NULL;
 p2 = p2->next;
 }
 }
 int k = 1;
 p1 = p1->next;
 p2 = p2->next->next;
 while(p1 != p2)
 {
 p1 = p1->next;
 p2 = p2->next->next;
 k++;
 }
 p1 = head;
 p2 = head;
 for(int i = 0;i < k;i++)
 {
 p2 = p2->next;
 }
 while(p1 != p2)
 {
 p1 = p1->next;
 p2 = p2->next;
 }
 return p1;
 }
};

[leetcode_19]Remove Nth Node From End of List

Fri, 22 May 2015 01:40:35 +0000

给一个单向链表，输入一个n，删掉从后往前第n个元素。尽可能一次遍历单链表。
两个指针，使他们的差距刚好为n, 当后面一个刚好指向NULL的时候，删掉前一个即可。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 ListNode *removeNthFromEnd(ListNode *head, int n) {
 ListNode *before = NULL;
 ListNode *p1 = head;
 ListNode *p2 = head;
 if(n <= 0) return head;
 for(int i = 0; i < n; i++) {
 p2 = p2->next;
 }
 while(p2 != NULL) {
 p2 = p2->next;
 before = p1;
 p1 = p1->next;
 }
 if(before == NULL) {
 return head->next;
 } else {
 before->next = p1->next;
 return head;
 }
 }
};

[leetcode_80]Remove Duplicates from Sorted Array II

Fri, 22 May 2015 01:39:17 +0000

模拟题，但是做起来好费劲啊。
一次AC:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 int removeDuplicates(int A[], int n) {
 if(n == 0)
 return n;
 int now;
 int count = 0;
 int len = n;
 for(int i = 0; i < len; i++) {
 if(count == 0 || now != A[i]) {
 count = 1;
 now = A[i];
 continue;
 }
 if(A[i] == now) {
 if(count == 2) {
 int dis = 0;
 int tmp = A[i];
 for(int j = i+1; j < len; j++) {
 if(tmp == A[j]) {
 dis++;
 } else {
 A[j-1-dis] = A[j];
 }
 }
 len -= 1 + dis;
 i--;
 } else {
 count++;
 }
 }
 }
 return len;
 }
};

[leetcode_73]Set Matrix Zeroes

Fri, 22 May 2015 01:38:02 +0000

给一个m*n矩阵，将该矩阵中出现0元素的位置的行列均置为0。
最简单的方法，开一个m*n的矩阵记录，再设置就行了。
更简单的是：开一个m+n的矩阵记录行列就可以了。
更更简单的常数空间的方法，我想了一种，有点问题，正在琢磨，先把m+n的解法贴出来吧。
一次AC。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


class Solution {
 public:
 void setRZeros(vector<vector<int> > &matrix,int x)
 {
 int m = matrix.size();
 int n = matrix[0].size();
 for(int i = 0;i < n;i++)
 {
 matrix[x][i] = 0;
 }
 }
 void setCZeros(vector<vector<int> > &matrix,int y)
 {
 int m = matrix.size();
 int n = matrix[0].size();
 for(int i = 0;i < m;i++)
 {
 matrix[i][y] = 0;
 }
 }
 void setZeroes(vector<vector<int> > &matrix) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int m = matrix.size();
 int n = matrix[0].size();
 int *R = new int[m];
 int *C = new int[n];
 memset(R,0,m*sizeof(int));
 memset(C,0,n*sizeof(int));
 for(int i = 0;i < m;i++)
 {
 for(int j = 0;j < n;j++)
 {
 if(matrix[i][j] == 0)
 {
 R[i] = 1;
 C[j] = 1;
 }
 }
 }
 for(int i = 0;i < m;i++)
 {
 if(R[i])
 setRZeros(matrix,i);
 }
 for(int i = 0;i < n;i++)
 {
 if(C[i])
 setCZeros(matrix,i);
 }
 }
};

[leetcode_62]Unique Paths

Fri, 22 May 2015 01:18:11 +0000

这个题因为原链接的图片挂了，不过根据题意，题意是：给一个m*n的矩阵，问有多少条路径可以从（0，0）点到（m-1，n-1）点。
走路的规则是一步只能从当前点往右或者往下走。
宽度优先搜索。
附上代码：
一次AC。目测代码性能还是不够好。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


struct PPoint {
 int x;
 int y;
};
class Solution {
public:
 bool CheckIn(int x, int y, PPoint *p, int top) {
 for(int i = 0; i < top; i++) {
 if(x == p[i].x && y == p[i].y) {
 return true;
 }
 }
 return false;
 }
 int uniquePaths(int m, int n) {
 int **map = new int*[m];
 for(int i = 0; i < m; i++) {
 map[i] = new int[n];
 }
 for(int i = 0; i < m; i++) {
 for(int j = 0; j < n; j++) {
 map[i][j] = 0;
 }
 }
 map[0][0] = 1;
 PPoint *p = new PPoint[m+n];
 PPoint *p_c = new PPoint[m+n];
 int index = 0;
 p[index].x = 0;
 p[index++].y = 0;
 while(true) {
 int top = 0;
 for(int i = 0; i < index; i++) {
 int x = p[i].x;
 int y = p[i].y;
 if(x + 1 < m) {
 map[x+1][y] += map[x][y];
 if(CheckIn(x+1, y, p_c, top) == false) {
 p_c[top].x = x+1;
 p_c[top++].y = y;
 }
 }
 if(y + 1 < n) {
 map[x][y+1] += map[x][y];
 if(CheckIn(x, y+1, p_c, top) == false) {
 p_c[top].x = x;
 p_c[top++].y = y+1;
 }
 }
 }
 if(top == 0) break;
 index = top;
 for(int i = 0; i < top; i++) {
 p[i].x = p_c[i].x;
 p[i].y = p_c[i].y;
 }
 }
 return map[m-1][n-1];
 }
};

[leetcode_48]Rotate Image

Fri, 22 May 2015 01:14:33 +0000

将一个n*n的矩阵顺时针旋转90度，额外地，能不能原地旋转，就是不开辟额外的空间。
一次AC, 每个位置上的旋转只会影响4个位置上的数组，开一个tmp，搞定。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 void MoveStep(vector<vector<int>> &matrix,int i,int j,int n)
 {
 int x1 = i;
 int y1 = j;

 int x2 = y1;
 int y2 = n - x1;

 int x3 = n - x1;
 int y3 = n - y1;

 int x4 = n - y1;
 int y4 = x1;

 int tmp = matrix[x4][y4];
 matrix[x4][y4] = matrix[x3][y3];
 matrix[x3][y3] = matrix[x2][y2];
 matrix[x2][y2] = matrix[x1][y1];
 matrix[x1][y1] = tmp;
 }

 void rotate(vector<vector<int>> &matrix) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int length = matrix.size();
 int n = length / 2;
 if(length % 2 == 0)
 {
 for(int i = 0; i < n; i++)
 {
 for(int j = 0; j < n; j++)
 {
 MoveStep(matrix, i, j, length-1);
 }
 }
 }
 else
 {
 for(int i = 0; i < n; i++)
 {
 for(int j = 0; j <= n; j++)
 {
 MoveStep(matrix, i, j, length-1);
 }
 }
 }
 }
};

[leetcode_137] Single Number II

Thu, 21 May 2015 08:25:03 +0000

给出 n 个数，里面每个数字重复 3 次，只有一个数字只出现一次，求该数字 [线性时间和空间]
相信两个数的大家都会，异或就行。
其实最开始用 map 过，觉得不符合题意，看了别人的思路，知道了，其实就是题目的变形，感觉不会举一反三，而且对问题的分析能力不够。
异或的目的就是计数每个位置出现 1 的个数，如果有两次就清零。
同理，3 个数我就出现 3 次清零。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Solution {
public:
 int singleNumber(int A[], int n) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int now = A[0];
 int one = now;
 int two = 0;
 int three = 0;
 for(int i = 1; i < n; i++)
 {
 int input = A[i];
 int in1 = one & input;
 one = one ^ input;
 int in2 = two & in1;
 two = two ^ in1;

 one = one ^ in2;
 }
 return one ^ two;
 }
};

[leetcode_22]Generate Parentheses

Thu, 21 May 2015 08:23:53 +0000

给定数n，生成所有的n个括号的情况。
比如n=2:(()),()()
这个题，回溯搜索所有情况即可：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 vector<string> ans;
 void genStep(string &item,int n,int countLeft,int countRight)
 {
 if(countLeft == n && countRight == n)
 {
 ans.push_back(item);
 return;
 }
 if(countLeft < n)
 {
 countLeft++;
 item.insert(item.length(),"(");
 genStep(item,n,countLeft,countRight);
 countLeft--;
 item = item.erase(item.length()-1,1);
 }
 if(countRight < n && countLeft > countRight)
 {
 countRight++;
 item.insert(item.length(),")");
 genStep(item,n,countLeft,countRight);
 countRight--;
 item = item.erase(item.length()-1,1);
 }
 }
 vector<string> generateParenthesis(int n) {
 ans.clear();
 if(n == 0)return ans;
 int countLeft = 1;
 int countRight = 0;
 string item = "(";
 genStep(item,n,countLeft,countRight);
 return ans;
 }
};

[leetcode_89]Gray Code

Thu, 21 May 2015 08:22:35 +0000

这个题，我很无奈，不能special judge。好吧开始写了一个代码 WA，人说 sorry 不能sp，于是按照样例改了改。
思想就是

1
在序列中的每个数前面[样例]或者后面加上（0，1），（1，0），（0，1），（1，0），（0，1），（1，0）……即可[每个数，生成两个新的数]，这样保证了只改变一个位数，因为上一轮的数是按照跪着的。所以这样就不会有问题。
附上两次的代码：
WA的代码[我相信是可以过的]：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 vector<int> grayCode(int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<int> seq;
 seq.clear();
 if(n == 0)
 {
 seq.push_back(0);
 return seq;
 }
 for(int i = 0;i < n;i++)
 {
 if(i == 0)
 {
 seq.push_back(0);
 seq.push_back(1);
 }
 else
 {
 vector<int>seq_copy;
 seq_copy.clear();
 int increase = (int)pow(2.0,i);
 int state = 0;
 for(int j = 0;j < seq.size();j++)
 {
 if(state == 0)
 {
 seq_copy.push_back(seq[j] + 0);
 seq_copy.push_back(seq[j] + increase);
 state = 1;
 }
 else
 if(state == 1)
 {
 seq_copy.push_back(seq[j] + increase);
 seq_copy.push_back(seq[j] + 0);
 state = 0;
 }
 }
 seq.clear();
 for(int j = 0;j < seq_copy.size();j++)
 {
 seq.push_back(seq_copy[j]);
 }
 }
 }
 return seq;
 }
};

AC的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


class Solution {
public:
 vector<int> grayCode(int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<int> seq;
 seq.clear();
 if(n == 0)
 {
 seq.push_back(0);
 return seq;
 }
 for(int i = 0;i < n;i++)
 {
 if(i == 0)
 {
 seq.push_back(0);
 seq.push_back(1);
 }
 else
 {
 vector<int>seq_copy;
 seq_copy.clear();
 int state = 0;
 for(int j = 0;j < seq.size();j++)
 {
 if(state == 0)
 {
 seq_copy.push_back((seq[j]<<1) + 0);
 seq_copy.push_back((seq[j]<<1)+1);
 state = 1;
 }
 else
 if(state == 1)
 {
 seq_copy.push_back((seq[j]<<1)+1);
 seq_copy.push_back((seq[j]<<1) + 0);
 state = 0;
 }
 }
 seq.clear();
 for(int j = 0;j < seq_copy.size();j++)
 {
 seq.push_back(seq_copy[j]);
 }
 }
 }
 return seq;
 }
};

[leetcode_24] Swap Nodes in Pairs

Thu, 21 May 2015 08:20:37 +0000

这个题其实就是个模拟题，两两交换 listnode 的节点，基于 node 而非 val。蛮简单的，但是我自己确实憋了好久，一次 AC，但是感觉自己的代码写出来永远不美，复用性不高。逻辑不行。还得加油。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
 ListNode *swapPairsStep(ListNode *head, int PairsNum) {
 ListNode *now = head;
 ListNode *before;
 for (int i = 0; i < PairsNum; i++) {
 now = now->next;
 before = now;
 now = now->next;
 }
 if (PairsNum == 0) {
 ListNode *tmp = now->next;
 now->next = now->next->next;
 tmp->next = now;
 return tmp;
 } else {
 ListNode *tmp = now->next;
 now->next = now->next->next;
 tmp->next = now;
 before->next = tmp;
 }
 return head;
 }

 bool IsCheck(ListNode *head, int PairsNum) {
 ListNode *now = head;
 for (int i = 0; i < PairsNum; i++) {
 now = now->next;
 now = now->next;
 }
 if (now != NULL && now->next != NULL) {
 return true;
 } else {
 return false;
 }
 }

 ListNode *swapPairs(ListNode *head) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int num = 0;
 while (IsCheck(head, num)) {
 head = swapPairsStep(head, num);
 num++;
 }
 return head;
 }
};

[leetcode_108]Convert Sorted Array to Binary Search Tree

Thu, 21 May 2015 08:17:25 +0000

注意什么都不输入的越界问题。
每次二分，因为排好序，以中点为根即可。
子树同理。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 TreeNode *sortedArrayToBST(vector<int> &num) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 if(num.size() <= 0)
 return NULL;
 int size = num.size()-1;
 int mid = size / 2;
 TreeNode * root = new TreeNode(num[mid]);
 TreeNode * left = GetNode(num,0,mid-1);
 TreeNode * right = GetNode(num,mid+1,size);
 root->left = left;
 root->right = right;
 return root;
 }
 TreeNode *GetNode(vector<int> &num,int a,int b)
 {
 if(a > b)
 {
 return NULL;
 }
 int mid = a + (b - a) / 2;
 TreeNode * node = new TreeNode(num[mid]);
 TreeNode * left = GetNode(num,a,mid-1);
 TreeNode * right = GetNode(num,mid+1,b);
 node->left = left;
 node->right = right;
 return node;
 }
};

[leetcode_110]Balanced Binary Tree

Thu, 21 May 2015 08:16:19 +0000

判断一棵树是否是平衡的二叉查找树。
一次AC附上代码：[原以为自己会超时的]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 bool ans;
 bool isBalanced(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 ans = true;
 if(root == NULL)
 return ans;
 Calc(root);
 return ans;
 }
 int Calc(TreeNode *node)
 {
 if(node == NULL)
 return 0;
 int left = Calc(node->left) + 1;
 int right = Calc(node->right) + 1;
 if(abs(left - right) > 1)
 {
 ans = false;
 }
 if(left > right)
 return left;
 else
 return right;
 }
};

[leetcode_75]Sort Colors

Thu, 21 May 2015 08:15:06 +0000

red white blue 三种颜色
分别用0 1 2代表
输入一个0 1 2 的数组，请排序。
但是不允许用封装好的库。
具体的方法是遍历该数组对012进行计数，然后对原数组覆盖即可。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 void sortColors(int A[], int n) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int count0 = 0;
 int count1 = 0;
 int count2 = 0;

 for(int i = 0; i < n; i++) {
 switch(A[i]) {
 case 0:
 count0++;
 break;
 case 1:
 count1++;
 break;
 case 2:
 count2++;
 break;
 }
 }

 for(int i = 0; i < count0; i++) {
 A[i] = 0;
 }
 for(int i = count0; i < count0 + count1; i++) {
 A[i] = 1;
 }
 for(int i = count0 + count1; i < count0 + count1 + count2; i++) {
 A[i] = 2;
 }
 }
};

[leetcode_112]Path Sum

Thu, 21 May 2015 08:13:49 +0000

给定一个二叉树，跟定一个数字sum，从根开始到各叶节点的路径依次求和，请问是否有叶节点的值满足和sum相等。
这个题，其实BFS然后依次枚举就行，但是注意边界，首先是叶节点，然后考虑root无子节点和root为空的情况。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


class Solution {
public:
 bool hasPathSum(TreeNode *root, int sum) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 TreeNode ** seq = new TreeNode*[10000];
 TreeNode ** rseq = new TreeNode*[10000];
 if(root == NULL)
 return false;
 else
 {
 if(root->left == NULL && root->right == NULL)
 {
 if(root->val == sum)
 return true;
 else
 return false;
 }
 int index = 0;
 seq[index++] = root;
 while(true)
 {
 int top = index;
 index = 0;
 for(int i = 0;i < top;i++)
 {
 if(seq[i] != NULL)
 {
 if(seq[i]->left != NULL)
 {
 seq[i]->left->val += seq[i]->val;
 rseq[index++] = seq[i]->left;
 if(seq[i]->left->val == sum && seq[i]->left->left == NULL && seq[i]->left->right == NULL)
 return true;
 }
 if(seq[i]->right != NULL)
 {
 seq[i]->right->val += seq[i]->val;
 rseq[index++] = seq[i]->right;
 if(seq[i]->right->val == sum && seq[i]->right->left == NULL && seq[i]->right->right == NULL)
 return true;
 }
 }
 }
 if(index == 0)
 break;
 for(int i = 0;i < index;i++)
 {
 seq[i] = rseq[i];
 }
 }
 return false;
 }
 }
};

[leetcode_107]Binary Tree Level Order Traversal II

Thu, 21 May 2015 08:12:31 +0000

二叉树从下至上的输出层
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 vector<vector<int> > levelOrderBottom(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<vector<int>> result;
 result.clear();
 TreeNode **seq = new TreeNode *[1000];
 TreeNode **rseq = new TreeNode *[1000];
 int index = 0;
 seq[index++] = root;
 while(true)
 {
 int top = index;
 index = 0;
 vector<int> tmp;
 tmp.clear();
 for(int i = 0 ;i< top;i++)
 {
 if(seq[i] != NULL)
 {
 tmp.push_back(seq[i]->val);
 if (seq[i]->left != NULL)
 {
 rseq[index++] = seq[i]->left;
 }
 if (seq[i]->right != NULL)
 {
 rseq[index++] = seq[i]->right;
 }
 }
 }
 if(tmp.size() > 0)
 result.push_back(tmp);
 if(index == 0)
 break;
 for(int i = 0;i < index;i++)
 {
 seq[i] = rseq[i];
 }
 }
 vector<vector<int>> ans;
 ans.clear();
 for(int i = result.size() - 1;i >= 0;i--)
 {
 ans.push_back(result[i]);
 }
 return ans;
 }
};

[leetcode_145]Binary Tree Postorder Traversal

Thu, 21 May 2015 08:11:21 +0000

二叉树的后序遍历，更加注重代码质量。一次AC，无测试。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 vector<int> postorderTraversal(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<int> result;
 result.clear();
 if (NULL != root) {
 Traversal(root->left, result);
 Traversal(root->right, result);
 result.push_back(root->val);
 }
 return result;
 }

 void Traversal(TreeNode * now, vector<int>& result) {
 if (NULL != now) {
 Traversal(now->left, result);
 Traversal(now->right, result);
 result.push_back(now->val);
 }
 }
};

[leetcode_94]Binary Tree Inorder Traversal

Thu, 21 May 2015 08:10:09 +0000

左根右，中序遍历
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 vector<int> result;
 vector<int> inorderTraversal(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 result.clear();
 if(root == NULL)
 return result;
 Traversal(root->left);
 result.push_back(root->val);
 Traversal(root->right);
 return result;
 }
 void Traversal(TreeNode * now)
 {
 if(now == NULL)
 return ;
 Traversal(now->left);
 result.push_back(now->val);
 Traversal(now->right);
 }
};

[leetcode_64]Minimum Path Sum

Thu, 21 May 2015 08:08:44 +0000

宽度优先搜索，之前TLE是因为写成了深度优先搜索。
后来一次AC附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


class Solution {
public:
 int rows;
 int cols;
 int minnow;
 int minPathSum(vector<vector<int>> &grid) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 rows = grid.size()-1;
 cols = grid[0].size()-1;

 vector<vector<int>> copygrid(grid.size());
 int sum = 0;
 for(int i = 0; i < grid.size(); i++) {
 for(int j = 0; j < grid[0].size(); j++) {
 sum += grid[i][j];
 }
 }

 for(int i = 0; i < grid.size(); i++) {
 vector<int> tmp(grid[0].size());
 for(int j = 0; j < grid[0].size(); j++) {
 tmp[j] = sum;
 }
 copygrid[i] = tmp;
 }
 copygrid[0][0] = grid[0][0];

 int px[10000], py[10000];
 int cpx[20000], cpy[20000];
 int index = 0;
 px[index] = 0;
 py[index++] = 0;
 while(true) {
 int top = index;
 index = 0;
 for(int i = 0; i < top; i++) {
 int x = px[i];
 int y = py[i];
 if(x + 1 <= rows) {
 if(copygrid[x][y] + grid[x+1][y] < copygrid[x+1][y]) {
 copygrid[x+1][y] = copygrid[x][y] + grid[x+1][y];
 cpx[index] = x+1;
 cpy[index] = y;
 index++;
 }
 }
 if(y + 1 <= cols) {
 if(copygrid[x][y] + grid[x][y+1] < copygrid[x][y+1]) {
 copygrid[x][y+1] = copygrid[x][y] + grid[x][y+1];
 cpx[index] = x;
 cpy[index] = y+1;
 index++;
 }
 }
 }
 if(index == 0)
 break;
 for(int i = 0; i < index; i++) {
 px[i] = cpx[i];
 py[i] = cpy[i];
 }
 }
 return copygrid[rows][cols];
 }
};

[leetcode_88]Merge Sorted Array

Thu, 21 May 2015 08:07:29 +0000

哇这个题，把B数组的数合并到A数组中，AB原本有序，合并之后依然有序。
插入排序。
不过为什么自己写个插排写得这么死呢。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


class Solution {
public:
 void merge(int A[], int m, int B[], int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 for(int i = 0;i < n;i++)
 {
 Insert(A,m+i,B[i]);
 }
 }
 void Insert(int A[],int lengthA,int val)
 {
 if(lengthA == 0)
 {
 A[lengthA] = val;
 return;
 }
 if(val > A[lengthA-1])
 {
 A[lengthA] = val;
 return ;
 }
 int i;
 for(i = lengthA-1;i >= 0;i--)
 {
 if(val < A[i])
 {
 A[i+1] = A[i];
 }
 else
 {
 A[i+1] = val;
 break;
 }
 }
 if(i == -1)
 {
 A[0] = val;
 }
 }
};

[leetcode_21]Merge Two Sorted Lists

Thu, 21 May 2015 08:05:52 +0000

合并两个有序单向链表。
一次AC
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


class Solution {
public:
 ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(l1 == NULL)
 return l2;
 if(l2 == NULL)
 return l1;
 int val;
 if(l1->val < l2->val)
 {
 val = l1->val;
 l1 = l1->next;
 }
 else
 {
 val = l2->val;
 l2 = l2 ->next;
 }
 ListNode * l = new ListNode(val);
 ListNode * lcopy = l;
 int flag = 0;
 while(true)
 {
 if(l1 == NULL)
 {
 flag = 1;
 break;
 }
 if(l2 == NULL)
 {
 flag = 2;
 break;
 }
 if(l1->val < l2->val)
 {
 val = l1->val;
 l1 = l1->next;
 }
 else
 {
 val = l2->val;
 l2 = l2 ->next;
 }
 ListNode * tmp = new ListNode(val);
 lcopy->next = tmp;
 lcopy = lcopy->next;
 }
 if(flag == 1)
 {
 while(l2 != NULL)
 {
 val = l2->val;
 l2 = l2->next;
 ListNode * tmp = new ListNode(val);
 lcopy->next = tmp;
 lcopy = lcopy->next;
 }
 }
 if(flag == 2)
 {
 while(l1 != NULL)
 {
 val = l1->val;
 l1 = l1->next;
 ListNode * tmp = new ListNode(val);
 lcopy->next = tmp;
 lcopy = lcopy->next;
 }
 }
 return l;
 }
};

[leetcode_101]Symmetric Tree

Thu, 21 May 2015 08:04:08 +0000

之前看编程珠玑的时候，记得先要有想法，就好像啊哈！灵机一动。
然后要有相应的很好的数据结构。
最后编码。
这是我的一个理解。
然后这个题，真心呵呵。
自从本蒟蒻知道了二叉树序列化之后，就各种用。然后在这儿就用不停的Wa，190个测试数据
188个通过。
蛋疼。
憋了一天，忍不住了，看别人的想法，哎哟我去！这么点代码，蛋疼。
其实就是递归。只是递归的时候注意技巧，原则就是镜像。
附上代码。修改思路之后，一次AC。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 bool isSymmetric(TreeNode *root) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(root == NULL)
 return true;
 return CheckEqual(root->left,root->right);
 }
 bool CheckEqual(TreeNode * left,TreeNode * right)
 {
 if(left == NULL && right == NULL)
 return true;
 if((left == NULL && right != NULL)||(left != NULL && right == NULL))
 return false;
 if(left->val != right->val)
 return false;
 return CheckEqual(left->left,right->right)&&CheckEqual(left->right,right->left);
 }
};

[leetcode_96]Unique Binary Search Trees

Thu, 21 May 2015 08:02:33 +0000

由于是二分查找树，根据根的不同来迭代。
附上代码。一次AC开始一直没想明白。哎。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 int numTrees(int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(n == 1)return 1;
 if(n == 2)return 2;
 if(n == 3)return 5;
 int *num = new int[n + 1];
 num[0] = 1;
 num[1] = 1;
 num[2] = 2;
 num[3] = 5;
 for(int i = 4;i <= n;i++)
 {
 num[i] = 0;
 for(int j = 1;j <= i;j++)
 {
 num[i] += num[j-1]*num[i-j];
 }
 }
 return num[n];
 }
};

[leetcode_144]Binary Tree Preorder Traversal

Thu, 21 May 2015 08:01:09 +0000

哎哟我擦。用递归让我 AC 了还不算我过，题目前面没打勾，对我这种有强迫症的人来说，好痛苦。回头想想别的办法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 vector<int> ans;
 vector<int> preorderTraversal(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 ans.clear();
 fun(root);
 return ans;
 }
 void fun(TreeNode *root) {
 if (root != NULL) {
 ans.push_back(root->val);
 if (root->left != NULL)
 fun(root->left);
 if (root->right != NULL)
 fun(root->right);
 }
 }
};

[leetcode_102]Binary Tree Level Order Traversal

Thu, 21 May 2015 07:59:36 +0000

序列化二叉树…..

一次AC附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 vector<vector<int> > levelOrder(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<vector<int>> ans;
 ans.clear();
 TreeNode ** seq = new TreeNode *[100000];
 TreeNode ** rseq = new TreeNode *[100000];

 int index = 0;
 seq[index++] = root;
 int top = index;
 while(true)
 {
 index = 0;
 vector<int> tmp;
 tmp.clear();
 int flag = 0;
 for(int i = 0;i < top;i++)
 {
 if(seq[i] != NULL)
 {
 if(seq[i]->left != NULL)
 rseq[index++] = seq[i]->left;
 if(seq[i]->right != NULL)
 rseq[index++] = seq[i]->right;
 tmp.push_back(seq[i]->val);
 flag = 1;
 }
 }
 if(flag == 1)
 ans.push_back(tmp);
 else
 break;
 if(index == 0)
 break;
 for(int i = 0;i < index;i++)
 {
 seq[i] = rseq[i];
 }
 top = index;
 }
 return ans;
 }
};

[leetcode_116]Populating Next Right Pointers in Each Node

Thu, 21 May 2015 03:03:31 +0000

这个题让我对二叉树的序列化有一个新的认识啦。

1
2 3
4 5 6

像这个树表示成：1 2 3 4 # 5 6
意义就是
1 | 2 3 | 4 # 5 6
分别是第一第二第三层。
这样的话只需要每次一层一层的枚举就好。
注意越界的问题，附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution {
public:
 void connect(TreeLinkNode *root) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int height = -1;
 TreeLinkNode * rootheight = root;
 while(rootheight != NULL)
 {
 height++;
 rootheight = rootheight->left;
 }
 int NumOfNodes = (int)pow(2.0,height+1) - 1;
 TreeLinkNode ** LinkNodeArray = new TreeLinkNode *[NumOfNodes];
 int index = 0;
 LinkNodeArray[index++] = root;
 int bottom = 0;
 int top = index;
 while(true)
 {
 if(bottom == top)
 break;
 for(int i = bottom;i < top;i++)
 {
 if(LinkNodeArray[i] == NULL)
 continue;
 if(i == top-1)
 {
 LinkNodeArray[i] ->next = NULL;
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 else
 {
 LinkNodeArray[i] ->next = LinkNodeArray[i+1];
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 }
 bottom = top;
 top = index;
 }
 }
};

[leetcode_74]Search a 2D Matrix

Thu, 21 May 2015 03:01:41 +0000

两次二分，一次AC，注意越界的问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


using namespace std;
class Solution {
public:
 bool searchMatrix(vector<vector<int>> &matrix, int target) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 if(matrix.size() <= 0)
 return false;
 if(target > matrix[matrix.size()-1][matrix[0].size()-1])
 return false;
 vector<int>cols(matrix.size());
 for(int i = 0; i < matrix.size(); i++) {
 cols[i] = matrix[i][matrix[0].size()-1];
 }
 int colindex = bsearch(0, (int)(matrix.size()), cols, target);
 if(colindex == -1)
 return true;
 int rowindex = bsearch(0, (int)(matrix[colindex].size()), matrix[colindex], target);
 if(rowindex == -1)
 return true;
 return false;
 }
 int bsearch(int left, int right, vector<int> seq, int target) {
 if(left > right) {
 return right + 1;
 }
 int mid = (left + right) / 2;
 if(seq[mid] == target) {
 return -1;
 } else if(seq[mid] < target) {
 return bsearch(mid+1, right, seq, target);
 } else {
 return bsearch(left, mid-1, seq, target);
 }
 }
};

[leetcode_141]Linked List Cycle

Thu, 21 May 2015 03:00:15 +0000

这个题，判断一个单链表是否存在闭环。不允许开辟额外的空间。
开始确实不知道怎么解，就去看别人的解法了。
大意是，两个指针，一个前进一步，另一个前进两步，如果到了NULL这两个指针还没出现相等的情况，欧克没有闭环，如果出现相等，就有闭环。
附上代码。个人觉得对指针和链表的操作我真心烂

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 bool hasCycle(ListNode *head) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 ListNode * step1 = head;
 ListNode * step2 = head;
 while(true)
 {
 if(step1 == NULL)
 {
 return false;
 }
 step1 = step1->next;

 if(step2 == NULL || step2->next == NULL)
 {
 return false;
 }

 step2 = step2->next->next;

 if(step1 == step2)
 {
 return true;
 }
 }
 }
};

[leetcode_119]Pascal’s Triangle II

Thu, 21 May 2015 02:53:53 +0000

注意k从0开始算。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 vector<int> getRow(int rowIndex) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 rowIndex++;
 vector<int> ans(rowIndex);
 if(rowIndex == 1)
 {
 ans[0] = 1;
 }
 else
 if(rowIndex == 2)
 {
 ans[0] = 1;
 ans[1] = 1;
 }
 else
 {
 ans[0] = 1;
 ans[1] = 2;
 ans[2] = 1;
 for(int i = 4;i <= rowIndex;i++)
 {
 ans[0] = 1;
 ans[i-1] = 1;
 for(int j = i-2;j >= 1;j--)
 {
 ans[j] = ans[j-1] + ans[j];
 }
 }
 }
 return ans;
 }
};

[leetcode_59] Spiral Matrix II

Thu, 21 May 2015 02:51:54 +0000

输出螺旋增长的矩阵，两次 AC 注意 n=0 的情况

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


class Solution {
public:
 vector<vector<int> > generateMatrix(int n) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<vector<int>> ans(n);
 if(n == 0)
 {
 ans.clear();
 return ans;
 }
 int **map = new int*[n];
 for(int i = 0; i < n; i++)
 {
 map[i] = new int[n];
 }
 int val = 1;
 int x = 0;
 int y = 0;
 int dir = 1; // 1 右 2 下 3 左 4 上
 int r1 = -1;
 int r2 = n;
 int l1 = -1;
 int l2 = n;
 while(true)
 {
 map[x][y] = val;
 switch(dir)
 {
 case 1:
 y++;
 if(y == l2)
 {
 dir = 2;
 y--;
 x++;
 r1++;
 }
 break;
 case 2:
 x++;
 if(x == r2)
 {
 dir = 3;
 x--;
 y--;
 l2--;
 }
 break;
 case 3:
 y--;
 if(y == l1)
 {
 dir = 4;
 y++;
 x--;
 r2--;
 }
 break;
 case 4:
 x--;
 if(x == r1)
 {
 dir = 1;
 x++;
 y++;
 l1++;
 }
 break;
 }
 if(val == n*n)
 break;
 val++;
 }
 for(int i = 0; i < n; i++)
 {
 vector<int> tmp(n);
 for(int j = 0; j < n; j++)
 {
 tmp[j] = map[i][j];
 }
 ans[i] = tmp;
 }
 return ans;
 }
};

[leetcode_118]Pascal’s Triangle

Wed, 20 May 2015 01:36:19 +0000

简单的数组或者vector操作，一次AC
找找上下行的关系。
附上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


class Solution {
public:
 vector<vector<int>> generate(int numRows) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<vector<int>> ans(numRows);
 for(int i = 1; i <= numRows; i++)
 {
 vector<int> tmp(i);
 if(i == 1)
 {
 tmp[0] = 1;
 ans[i-1] = tmp;
 continue;
 }
 if(i == 2)
 {
 tmp[0] = 1;
 tmp[1] = 1;
 ans[i-1] = tmp;
 continue;
 }
 tmp[0] = 1;
 tmp[i-1] = 1;
 for(int j = 1; j < i-1; j++)
 {
 tmp[j] = ans[i-2][j-1] + ans[i-2][j];
 }
 ans[i-1] = tmp;
 }
 return ans;
 }
};