Orztu The Way | Orz途

小米路由添加开机启动

Mon, 01 Sep 2025 13:35:00 +0800

前置：使用 https://github.com/openwrt-xiaomi/xmir-patcher 解锁 ssh。

添加开机启动脚本

脚本需要使用 chmod +x /etc/crontabs/patches/*.sh 添加执行权限

使用 uci 添加 firewall 配置：

1
2
3
4
5
6


uci set firewall.startup=include
uci set firewall.startup.type='script'
uci set firewall.startup.path='/etc/crontabs/patches/startup.sh'
uci set firewall.startup.enabled='1'

uci commit firewall

自定义脚本内容：

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


#!/bin/sh
# /etc/crontabs/patches/startup.sh

[ -e "/tmp/startup.log" ] && return 0

# 执行命令
echo "Hello World!"

# 异步执行 startup_delay.sh
( sleep 20; /etc/crontabs/patches/startup_delay.sh ) &

echo "Done!" > /tmp/startup.log

延迟执行脚本

因为启动顺序问题，部分命令可能需要延迟执行，所以增加了 startup_delay.sh。

这里三条命令是解决光猫使用桥接模式+小米路由播号，无法在内网访问光猫的问题。

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


#!/bin/sh
# /etc/crontabs/patches/startup_delay.sh

[ -e "/tmp/startup_delay.log" ] && return 0

# 给 eth0 添加光猫网段地址 192.168.1.2
ifconfig eth0:1 192.168.1.2 netmask 255.255.255.0 up

#　使用 iptables 转发内网流量
iptables -I FORWARD -i br-lan -d 192.168.1.0/24 -j ACCEPT
iptables -t nat -I POSTROUTING -o eth0 -d 192.168.1.0/24 -j MASQUERADE

echo "Done!" > /tmp/startup_delay.log

Running

Wed, 30 Jul 2025 10:22:57 +0800

Git is very slow in WSL

Fri, 25 Dec 2020 10:37:10 +0800

Git

最近切换到 Windows 工作，使用 WSL 作为命令行方案。但在 WSL 里面安装 git 后，在工程里面执行命令时，总感觉非常缓慢。
执行一下 git status 都要卡好一会儿。

经过一番搜索，原因大概是 Windows 的路径索引到 WSL 之间有一个转换导致的？具体没有细看。

但找到一个解决方案：

先在 Windows 中安装 Git，然后在 WSL 里面用 git.exe 替代 Linux 版本的 git。

因为我使用的oh-my-zsh，所以通过在.zshrc中定义git函数针对 WSL 路径和 Windows 路径区别处理（这个代码是抄的）：

1
2
3
4
5
6
7


function git() {
 if $(pwd -P | grep -q "^\/mnt\/.\/*"); then
 git.exe "$@"
 else
 command git "$@"
 fi
}

但这样做需要注意两个环境的.gitconfig不是共用的。
可以配置includeIf，通过匹配 gitdir，在 WSL 里面引用 Windows 的 .gitconfig；又在 Windows 里面引用 WSL 的 .gitconfig。

其它

然后依葫芦画瓢:

在 WSL 中以用 Windows 环境打开 VS Code (如果是用 code 命令，打开的是 WSL 环境下的)：
1 2 3

function code_win() { cmd.exe /c code.cmd $(wslpath -w "$@") }

用 open 打开资源管理器：

1
2
3
4


function open() {
 explorer.exe $(wslpath -w "$@")
 return 0
}

LeetCode 98. Validate Binary Search Tree

Wed, 01 Apr 2020 17:20:18 +0800

Description

Validate Binary Search Tree

Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node’s key.

The right subtree of a node contains only nodes with keys greater than the node’s key.

Both the left and right subtrees must also be binary search trees.

Example 1:
1
2
3
 2
 / \
 1 3
Input: [2,1,3]

Output: true
Example 2:
1
2
3
4
5
 5
 / \
 1 4
 / \
 3 6
Input: [5,1,4,null,null,3,6]

Output: false

Explanation: The root node’s value is 5 but its right child’s value is 4.

验证二叉搜索树。

Solution

中序遍历时，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:
 bool isValidBST(TreeNode* root) {
 if (!root) {
 return true;
 }

 long first = LONG_MIN;
 return visit(root, first);
 }

private:
 bool visit(TreeNode* root, long &last) {
 if (root->left && !visit(root->left, last)) {
 return false;
 }

 if (root->val <= last) {
 return false;
 }
 last = root->val;

 if (root->right && !visit(root->right, last)) {
 return false;
 }

 return true;
 }
};

LeetCode 97. Interleaving String

Tue, 31 Mar 2020 09:02:58 +0800

Description

Interleaving String

Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

Example 1:

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"

Output: true

Example 2:

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"

Output: false

Solution

题目：

判断s3是否由s1、s2相互交错而成。

解：

判断由s1、s2组成的地图，是否存在路径s3；

Example1如下图，有多个解：

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


Example1:

s3: aadbbcbcac

 a a b c c (s1)
 a_a
 d d
 b b
 b b
 c c_b_c
 a a_c

(s2)

 a a b c c (s1)
 a_a
 d d_b
 b b_c
 b b
 c c
 a a_c

(s2)

 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:
 bool isInterleave(string s1, string s2, string s3) {
 auto width = s1.length() + 1;
 auto height = s2.length() + 1;

 if (width + height - 2 != s3.length()) {
 return false;
 }

 if (width == 1 || height == 1) {
 return (s1.compare(s3) == 0) || (s2.compare(s3) == 0);
 }

 std::vector<std::vector<bool>> dp;
 dp.resize(width);
 for (auto &v : dp) {
 v.resize(height);
 }

 // 初始化第一个位置，然后在循环中判断是否可能往右边/下边走。
 dp[0][0] = true;

 for (int i = 0; i < width; ++i) {
 for (int j = i == 0 ? 1: 0; j < height; ++j) {
 char c = s3.at(j + i - 1);

 // 尝试吃掉s1的字符，则只能由左边走过来
 // 如果是上方格子为true,表示当前字符已经使用，不能再次使用
 if (i > 0 && s1.at(i - 1) == c && dp[i-1][j]) {
 dp[i][j] = true;
 }

 // 尝试吃掉s2的字符，则只能由上边走过来
 if (j > 0 && s2.at(j - 1) == c && dp[i][j-1]) {
 dp[i][j] = true;
 }
 }
 }

 return dp[width-1][height-1];
 }
};

LeetCode 96. Unique Binary Search Trees

Mon, 30 Mar 2020 11:32:28 +0800

Description

Unique Binary Search Trees

Given n, how many structurally unique BST’s (binary search trees) that store values 1 … n?

Example:
Input: 3

Output: 5

Explanation:
Given n = 3, there are a total of 5 unique BST’s:
1
2
3
4
5
 1 3 3 2 1
 \ / / / \ \
 3 2 1 1 3 2
 / / \ \
 2 1 2 3

Solution

以n = 3为例，有数字1、2、3；设解为F(3)=f(1~3)；

对F(3)分解：

如果以1为root结点，则右边2~3有F(2)=f(2~3)个解
如果以2为root，则左边有F(1)=f(1~1)、右边有F(1)=f(3~3)；总F(1)*F(1)
如果以3为root，则左边有F(2)=f(1~2)

对于1和3两种情形，左边/右边有0个数，我们设为F(0)=1。

最终：F(3) = F(0)*F(2) + F(1)*F(1) + F(2)*F(0)个解。

所以可推导出DP公式：

$$ F(n) = \sum_{i=0}^{n}F(i) * F(n-i-1) ; F(0) = 1; $$

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


class Solution {
public:
 int numTrees(int n) {
 int *dp = new int[n+1]{1, 1}; // {F(0), F(1)}

 for (int i = 2; i <= n; ++i) {
 dp[i] = 0;
 for (int k = 0; k < i; ++k) {
 dp[i] += (dp[k] * dp[i - k - 1]);
 }
 }

 int r = dp[n];
 delete []dp;
 return r;
 }
};

LeetCode 94. Binary Tree Inorder Traversal

Thu, 26 Mar 2020 11:18:43 +0800

Description

Binary Tree Inorder Traversal

Given a binary tree, return the inorder traversal of its nodes’ values.

Example:
1
2
3
4
5
6
7
8
Input: [1,null,2,3]
 1
 \
 2
 /
 3

Output: [1,3,2]
Follow up: Recursive solution is trivial, could you do it iteratively?

Solution

 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<int> inorderTraversal(TreeNode* root) {
 vector<int> r;
 inorderVisit(r, root);
 return r;
 }

private:
 void inorderVisit(vector<int> &r, TreeNode *node) {
 std::stack<TreeNode *> s;
 auto *cur = node;
 while(cur || !s.empty()) {
 while(cur) {
 s.push(cur);
 cur = cur->left;
 }
 cur = s.top();
 s.pop();
 r.push_back(cur->val);
 cur = cur->right;
 }
 }

 /* 递归
 void inorderVisit(vector<int> &r, TreeNode *node) {
 if (!node) {
 return;
 }
 if (node->left) {
 inorderVisit(r, node->left);
 }
 r.push_back(node->val);
 if (node->right) {
 inorderVisit(r, node->right);
 }
 }
 */
};

LeetCode 93. Restore IP Addresses

Mon, 25 Nov 2019 15:23:55 +0800

Description

Restore IP Addresses

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

Example:
1
2
Input: "25525511135"
Output: ["255.255.11.135", "255.255.111.35"]

Solution

 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:
 Solution() : _empty(""), _dot(".") {
 }

 vector<string> restoreIpAddresses(string s) {
 vector<string> result;

 solve(result, "", 0, s);

 return result;
 }

 void solve(vector<string> &result, string ip, int n, string s) {
 size_t len = s.length();

 if (n == 4 ) {
 if (len == 0) {
 result.push_back(ip);
 }
 return;
 }

 string &mid = n > 0 ? _dot : _empty;

 int cur = 0;
 for (size_t i = 0; i < len; i++) {
 cur = cur*10 + static_cast<int>(s.at(i) - '0');
 if (cur > 255) {
 return;
 }

 solve(result, ip + mid + s.substr(0, i+1), n + 1, s.substr(i+1));

 if (cur == 0) {
 return;
 }
 }
 }

private:
 string _empty;
 string _dot;
};

跑跑卡丁车手游 L1 驾照“下坡漂移”教程

Thu, 11 Jul 2019 17:52:17 +0800

»>视频地址«<

首先我们要在前两个门集满第一管氮气。
1号门前向右轻打方向调整车头，然后向左拖漂。
右漂经过2号门然后向左拉正车头后使用第一个氮气。

立即向右拖漂经过3号门。
氮气满之后马上拉正车头。
继续使用氮气，然后拖漂经过4号门，同样气满之后回正。
趁氮气未结束，再次拖漂经过5号门，然后马上使用氮气。
5号门相对前面两个门不用漂那么大。
过了5号门氮气满了断位拉头，然后接左漂继续集气并过6号门。
7号门前这个小坎需要小漂一下，不然落地容易弹起。
落地走一点点之后，向左轻漂，不要太大。
因为已经有两个氮气了，漂满了这一管就浪费了。
过这个坎向右轻漂，然后落地马上使用氮气。
然后把刚才没满的氮气漂满，这样又有两个氮气了。
紧接着再次把氮气漂到快满，以便下坡起跳之后集气。
使用氮气加速下坡，起跳前向左轻漂，不要用力。
落地之后氮气满了马上使用氮气纠正车头，避免撞墙；
如果前面失误，这个时候没有氮气，可以再次向左漂避免撞墙。
这个坎前向右漂移过弯，同样满了就用氮气回正；
如果没有氮气可用，就向左拉车头集气，然后使用氮气。
下一个弯车速起来就向左拖漂过弯，并集满一管气。
出弯后使用氮气，调整位置，准备从外道插入下一个弯。
这个弯向右打死，出弯使用氮气或者断位拉头。-
出弯之后等速度起来拖漂过最后一个弯。
最后一下起跳前向左轻漂。
剩余的直线就交给氮气了。

»>视频地址«<

$ N_{2}O $ 本是笑气，但在跑跑里面被大家称为“氮气”

ffmpeg 命令行

Sat, 15 Jun 2019 14:45:05 +0800

首先，并非专业视频处理人员；以下命令都是我从网上搜索后修改以为己所用。

图片转视频

1
2
3
4
5


# gif 转视频（DURATION：时长，gif会循环播放）
ffmpeg -ignore_loop 0 -t DURATION -f gif -i "INPUT.gif" -vcodec libx264 -crf 5 "OUTPUT.mp4"

# png、jpg 转视频
ffmpeg -loop 1 -framerate 30 -f image2 -t DURATION -i "INPUT.jpg" -vcodec libx264 -crf 5 "OUTPUT.mp4"

给视频添加音轨

1

ffmpeg -y -i "INPUT.mp4" -f lavfi -i anullsrc=channel_layout=stereo:sample_rate=44100 -shortest -c copy -c:a aac -bsf:v h264_mp4toannexb "OUTPUT.mp4"

修改视频分辨率

使用以下命令可以将视频分辨率修改为1280x768，不同比例的视频会填充黑边

1

ffmpeg -i "INPUT.mp4" -vf "scale=1280:768:force_original_aspect_ratio=decrease,pad=1280:768:(ow-iw)/2:(oh-ih)/2" OUTPUT.mp4

合并视频

如果视频都是相同格式，可以将视频用一下格式列举在一个文件中（也可以用来合并 mp3 文件）：

1
2
3
4


# concat.txt
file input1.mp4
file input2.mp4
file input3.mp4

然后使用以下命令拼接：

1

ffmpeg -safe 0 -f concat -i "concat.txt" -c copy "OUTPUT.mp4"

如果是不同格式的视频合并：

1
2
3
4


ffmpeg -i INPUT1.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts input1.ts
ffmpeg -i INPUT2.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts input2.ts
ffmpeg -i INPUT3.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts input3.ts
ffmpeg -y -i "concat:input1.ts|input2.ts|input3.ts" -c copy -bsf:a aac_adtstoasc -movflags +faststart OUTPUT.mp4

截取视频段

以下命令将从视频 1 分钟的位置开始，截取 15 秒。不要用-c copy，不然视频会缺少关键帧。

1

ffmpeg -ss 00:01:00 -accurate_seek -i INPUT.mp4 -t 15 OUTPUT.mp4

加速视频和音频

以下命令将 mp3 加速为1.1倍

1

ffmpeg -i INPUT.mp3 -filter_complex "[0:a]atempo=1.1[a]" -map "[a]" "OUTPUT.mp3"

以下命令将视频和音频同时加速为1.3倍（1/1.3 = 0.769230769231）

1

ffmpeg -i INPUT.mp4 -filter_complex "[0:v]setpts=0.769230769231*PTS[v];[0:a]atempo=1.300000[a]" -map "[v]" -map "[a]" OUTPUT.mp4

添加srt字幕

1

ffmpeg -i INPUT.mp4 -i INPUT.srt -c:s mov_text -c:v copy -c:a copy OUTPUT.mp4

LeetCode 92. Reverse Linked List II

Wed, 20 Mar 2019 14:59:04 +0800

Description

Reverse Linked List II

Reverse a linked list from position m to n. Do it in one-pass.

Note: 1 ≤ m ≤ n ≤ length of list.

Example:
1
2
Input: 1->2->3->4->5->NULL, m = 2, n = 4
Output: 1->4->3->2->5->NULL

遍历一次将链表的第m至n个结点翻转。

Solution

 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


func reverseBetween(head *ListNode, m int, n int) *ListNode {
 slow := &ListNode{
 Next: head,
 }
 fast := slow.Next
 head = slow

 for i := 1; i < m; i++ {
 fast = fast.Next
 slow = slow.Next
 }

 // start指向第一个需要翻转的位置
 pre, start := slow, fast

 // 进行翻转
 // 1. 将fast.Next倒转，指向slow
 // 2. 同时fast和slow前进一步
 for i := m; i <= n; i++ {
 fast.Next, fast, slow = slow, fast.Next, fast
 }

 pre.Next = slow
 start.Next = fast

 return head.Next
}

LeetCode 91. Decode Ways

Wed, 30 Jan 2019 17:19:21 +0800

Description

Decode Ways

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

1
2
3
4


'A' -> 1
'B' -> 2
...
'Z' -> 26

Given a non-empty string containing only digits, determine the total number of ways to decode it.

Example 1:

1
2
3


Input: "12"
Output: 2
Explanation: It could be decoded as "AB" (1 2) or "L" (12).

Example 2:

1
2
3


Input: "226"
Output: 3
Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).

Solution

 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


func numDecodings(s string) int {
 if len(s) == 0 || s[0] == '0' {
 return 0
 }

 dp := make([]int, len(s)+1)
 dp[0] = 1
 dp[1] = 1

 for i := 1; i < len(s); i++ {
 if s[i] == '0' {
 if s[i-1] == '1' || s[i-1] == '2' {
 // if this number is '0'
 // the previous number must be '1' or '2'
 // and the previous solution(dp[i]) should return to dp[i-1]
 // dp[i] = dp[i-1]
 dp[i+1] = dp[i-1]
 } else {
 return 0
 }
 } else if s[i-1] == '1' || (s[i-1] == '2' && s[i]-'0' <= 6) {
 // if this number is not '0'
 // like 226, when i is 2, number is 6
 // it can be splitted as "2|26" or "22|6"
 // so it can be from [2] and [22]
 dp[i+1] = dp[i] + dp[i-1]
 } else {
 // else there is only one way
 dp[i+1] = dp[i]
 }
 }

 return dp[len(s)]
}

LeetCode 90. Subsets II

Wed, 30 Jan 2019 15:59:41 +0800

Description

Subsets II

Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Input: [1,2,2]
Output:
[
 [2],
 [1],
 [1,2,2],
 [2,2],
 [1,2],
 []
]

假设没有重复元素，每个元素有出现、不出现两种情况。

当有重复元素后，假设重复元素：[2, 2, 2]，对于元素2有不出现、出现一次[2]、出现两次[2, 2]、出现三次[2, 2, 2]
四种情况。

Solution

 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


func subsetsWithDup(nums []int) [][]int {
 sort.Ints(nums)

 result := [][]int{[]int{}}

 for i := 0; i < len(nums); {
 curLen := len(result)

 // cout of this number
 count := 1
 for j := i + 1; j < len(nums) && nums[j] == nums[i]; j++ {
 count++
 }

 for idx := 0; idx < curLen; idx++ {
 for k := 1; k <= count; k++ {
 r := make([]int, len(result[idx]))
 copy(r, result[idx])

 // if the numver is visible
 // and if it's duplicate, eg. [2, 2, 2]
 // we can put in [2]、 [2, 2] or [2, 2, 2]
 for n := 0; n < k; n++ {
 r = append(r, nums[i])
 }

 result = append(result, r)
 }
 }

 i += count
 }

 return result
}

LeetCode 88. Merge Sorted Array

Thu, 03 Jan 2019 11:46:11 +0800

Description

Merge Sorted Array

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

Note:

The number of elements initialized in nums1 and nums2 are m and n respectively.

You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.

Example:
1
2
3
4
5
Input:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

Output: [1,2,2,3,5,6]

将nums1、nums2两个有序数组合并到nums1一个中，nums1已分配足够空间存放元素。

Solution

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


func merge(nums1 []int, m int, nums2 []int, n int) {
 // from back to front
 for i := m + n - 1; i >= 0; i-- {
 n1, n2 := math.MinInt64, math.MinInt64

 if m > 0 {
 n1 = nums1[m-1]
 }
 if n > 0 {
 n2 = nums2[n-1]
 }

 // move the bigger one to the tail
 // then dec the count
 if n1 >= n2 {
 nums1[i] = n1
 m--
 } else {
 nums1[i] = n2
 n--
 }
 }
}

LeetCode 87. Scramble String

Thu, 03 Jan 2019 09:14:13 +0800

Description

Scramble String

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

1
2
3
4
5
6
7


 great
 / \
 gr eat
 / \ / \
g r e at
 / \
 a t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

1
2
3
4
5
6
7


 rgeat
 / \
 rg eat
 / \ / \
r g e at
 / \
 a t

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

1
2
3
4
5
6
7


 rgtae
 / \
 rg tae
 / \ / \
r g ta e
 / \
 t a

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

Example 1:

1
2


Input: s1 = "great", s2 = "rgeat"
Output: true

Example 2:

1
2


Input: s1 = "abcde", s2 = "caebd"
Output: false

Solution

You may considering the string is not always split at the middle.

The tree could be like this:

1
2
3
4
5
6


 great
 / \
 g reat
 / \
 r eat
 ...

Divide And Conquer (Top to Down)

 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


func isScramble(s1 string, s2 string) bool {
 if s1 == s2 {
 return true
 }

 length := len(s1)

 // couting letters
 var count [26]int
 for i := 0; i < length; i++ {
 count[s1[i]-'a']++
 count[s2[i]-'a']--
 }

 // Does letters same?
 for i := 0; i < 26; i++ {
 if count[i] != 0 {
 return false
 }
 }

 for k := 1; k < length; k++ {
 if isScramble(s1[k:], s2[k:]) && isScramble(s1[:k], s2[:k]) {
 return true
 }

 // exchange substrings
 if isScramble(s1[k:], s2[:length-k]) && isScramble(s1[:k], s2[length-k:]) {
 return true
 }
 }

 return false
}

Dynamic Programming (Bottom to Up)

Definition dp[l][i][j]:

s1[i] start from 'i'
s2[j] start from 'j'
'l' is the length of substring, the length in recursive solution.

Initialization dp[1][i][j] = (s1[i] == s2[j] ? true : false).

1
2
3
4
5
6


dp[l][i][j] =
 // isScramble(s1[k:], s2[k:]) && isScramble(s1[:k], s2[:k])
 (dp[k][i][j] && dp[l-k][i+k][j+k]) ||

 // isScramble(s1[k:], s2[:length-k]) && isScramble(s1[:k], s2[length-k:])
 (dp[k][i][j+l-k] && dp[l-k][i+k][j])

k means split the l to two parts, so 0 <= k <= l;

 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


func isScramble(s1 string, s2 string) bool {
 if len(s1) != len(s2) {
 return false
 }

 length := len(s1)

 dp := make([][][]bool, length+1)
 for i := 0; i <= length; i++ {
 dp[i] = make([][]bool, length)
 for j := 0; j < length; j++ {
 dp[i][j] = make([]bool, length)
 }
 }

 for i := 0; i < length; i++ {
 for j := 0; j < length; j++ {
 dp[1][i][j] = (s1[i] == s2[j])
 }
 }

 for l := 2; l <= length; l++ {
 for i := 0; i < length-l+1; i++ {
 for j := 0; j < length-l+1; j++ {
 if dp[l][i][j] {
 continue
 }

 for k := 1; k < l && (!dp[l][i][j]); k++ {
 dp[l][i][j] = (dp[k][i][j] && dp[l-k][i+k][j+k]) ||
 (dp[k][i][j+l-k] && dp[l-k][i+k][j])
 }
 }
 }
 }

 return dp[length][0][0]
}

记一次 Cocos2dx-Lua 闪退

Sat, 22 Dec 2018 09:22:48 +0800

闪退点

Version: Cocos2dx-Lua 3.16

在某个页面修改后，出现闪退。查看修改记录没有特别的地方，均为修改图片或者条件判断。

启动 XCode 发现闪退位置出现在void Node::onEnterTransitionDidFinish()中，
在其调用子节点的child->onEnterTransitionDidFinish()时，child指针无效。

1352
1353
1354


...
for( const auto &child: \_children)
child->onEnterTransitionDidFinish();

此时的调用栈：

1
2
3
4


0: void Node::onEnterTransitionDidFinish() -> child->onEnterTransitionDidFinish();
1: void Director::setNextScene() -> _runningScene->onEnterTransitionDidFinish();
2: void Director::drawScene() -> setNextScene();
...

对应 Lua 代码流程：

1
2
3
4


display.runScene(HomeScene)
HomeScene:ctor() {
 self:addChild(HomeLayer)
}

怀疑

因为是在调用Scene::onEnterTransitionDidFinish()时指针无效，所以猜测是遍历过程中字节点被删除。

查看相关代码：

1
2
3
4


HomeScene: 没有 onEnterTransitionDidFinish()
HomeLayer: 有 onEnterTransitionDidFinish()，
 但在 onEnterTransitionDidFinish 中没有删除 HomeScene 上的结点。
 而是往 Scene 上新增结点 addChild(GuideLayer)

因为游戏逻辑是只创建一个GuideLayer，重复创建时会删除上次创建的页面。又怀疑是否创建了两次GuideLayer。
通过屏蔽代码发现不添加GuideLayer就不会闪退，但是GuideLayer的确只创建了一次，不存在删除问题。

真相

再次分析流程

1
2
3
4
5
6


HomeScene:onEnterTransitionDidFinish():
 HomeLayer:onEnterTransitionDidFinish(
 addChild(GuideLayer) // 添加到HomeScene上
 )

HomeScene:onEnterTransitionDidFinish() 闪退

总归问题是出现在HomeScene的_children容器上，那么既然不是删除，增加结点会导致容器出问题吗？

查找代码得到_children类型为CCVector，而CCVector通过std::vector实现。

所以出现了常见的**问题：在容器迭代过程中删除或插入**。

在新增结点往std::vector插入的时候，恰好超过容量大小，导致扩容。而std::vector是分配的连续内存，
所以扩容时候会重新分配内存，导致遍历的时候出现child指针无效。

1
2
3
4
5
6
7
8


scene::onEnterTransitionDidFinish() {
    for (child: scene->children) {       
 // onEnterTransitionDidFinish里面往scene中addChild
        // 导致children容器扩容，for循环的child指针失效
        // 然后下一轮循环再到这里，child(无效指针)->onEnterTransitionDidFinish()就会闪退
        child->onEnterTransitionDidFinish();  
    }  
}

else

那么是不是就不能在onEnterTransitionDidFinish中添加结点呢？

在这个项目，许多页面都在onEnterTransitionDidFinish往HomeScene添加GuideLayer；或者在当前页面添加结点，为啥运行了这么久都没发现问题？

查看代码可以得到，C++ 中onEnterTransitionDidFinish是在遍历完子节点后，
再发送消息调用Lua中的onEnterTransitionDidFinish的：

1
2
3
4
5


for( const auto &child: _children)
 child->onEnterTransitionDidFinish();
...
// 调用当前结点 Lua 的 onEnterTransitionDidFinish
ScriptEngineManager::sendNodeEventToLua(this, kNodeOnEnterTransitionDidFinish);

而项目中的页面管理是这样做的：进入游戏创建HomeScene，之后其他页面跳转均在HomeScene上删除和添加，几乎不会创建新 Scene 。

所以后面不会再遇到HomeScene::onEnterTransitionDidFinish遍历时添加子结点的情况；而直接往当前页面添加结点，也是在当前页面的_children遍历完后再添加的(Lua 中添加)。

LeetCode 86. Partition List

Tue, 18 Dec 2018 10:07:22 +0800

Description

Partition List

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

Example:
1
2
Input: head = 1->4->3->2->5->2, x = 3
Output: 1->2->2->4->3->5

Solution

 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


func partition(head *ListNode, x int) *ListNode {
 // use a new linked list to save 'bigger nodes'
 bigger := &ListNode{}
 biggerTail := bigger

 // this linked list to save 'smaller nodes'
 slow := &ListNode{
 Next: head,
 }
 head = slow
 fast := slow.Next

 for fast != nil {
 if fast.Val < x {
 // slow go to fast(go to slow.next)
 slow = fast
 } else {
 // skip fast, go fast.Next(got slow.next.next)
 slow.Next = fast.Next

 // break after fast
 fast.Next = nil

 // append fast to bigger linked list
 biggerTail.Next = fast
 biggerTail = biggerTail.Next
 }
 fast = slow.Next
 }

 // concat the two linked lists
 slow.Next = bigger.Next

 return head.Next
}

在 Golang 中打印调用栈信息

Wed, 12 Dec 2018 15:38:49 +0800

在日志信息中，有时需要获取当前函数的调用信息，比如打印调用栈：

调用栈

debug.Stack() []byte

debug.Stack()函数可以获取当前 goroutine 的调用栈信息，需要import "runtime/debug"。

 8
 9
10
11
12
13
14
15
16
17
18
19
20


func foo() {
 fmt.Println("--- BEGIN ---")
 fmt.Println(string(debug.Stack()))
 fmt.Println("--- END ---")
}

func boom() {
 foo()
}

func main() {
 boom()
}

可以获得类似输出结果：

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


--- BEGIN ---
goroutine 1 [running]:
runtime/debug.Stack(0xc00006ef58, 0x1, 0x1)
 /usr/local/Cellar/go/1.11.2/libexec/src/runtime/debug/stack.go:24 +0xa7
main.foo()
 xxx/trace.go:10 +0x66
main.boom()
 xxx/trace.go:15 +0x20
main.main()
 xxx/trace.go:19 +0x20

--- END ---

runtime.Stack(buf []byte, all bool) int

debug.Stack()函数源码在runtime/debug/stack.go中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func Stack() []byte {
 buf := make([]byte, 1024)
 for {
 n := runtime.Stack(buf, false)
 if n < len(buf) {
 return buf[:n]
 }
 buf = make([]byte, 2*len(buf))
 }
}

可以看到它是通过调用runtime.Stack获取的调用栈信息，
其中第二个参数all表示是否获取所有 goroutine 的调用栈。

可以将第二个参数改为true然后创建多个 goroutine 查看输出效果。

更可控的调用信息

上面两个函数虽然可以获取调用栈，但是直接将所有调用信息返回，控制参数较少。

下面几个函数可以实现获取单层的调用信息。

runtime.Caller(skip int) (pc uintptr, file string, line int, ok bool)

runtime.Caller函数可以获取调用者的信息

参数skip：表示跳过的层级，相当于往上获取第几层的调用者。0 表示当前函数，1 表示上一层函数，依次往上。
返回值
- pc：program counter（不知道该怎么翻译，程序计数器？），可以大概理解为函数编号，可以通过runtime.FuncForPC解析
- file：文件名
- line：行号

 8
 9
10
11
12
13


func foo() {
 pc, file, line, ok := runtime.Caller(1)
 if ok {
 fmt.Println(runtime.FuncForPC(pc).Name(), file, line)
 }
}

可以得到这样一条输出：

1

main.boom xxx/trace.go 16

runtime.Callers(skip int, pc []uintptr) int

runtime.Callers一次可以获取调用栈中多个program counter。

但是第一个参数skip与上面的runtime.Caller稍有不同，如果传0会获取到Callers函数本身的信息。
传1时才与上面的Caller函数对应。

 8
 9
10
11
12
13
14
15
16


func foo() {
 pc := make([]uintptr, 10)
 n := runtime.Callers(1, pc)
 for i := 0; i < n; i++ {
 f := runtime.FuncForPC(pc[i])
 file, line := f.FileLine(pc[i])
 fmt.Printf("%s %d %s\n", file, line, f.Name())
 }
}

输出：

1
2
3
4
5


xxx/trace.go 10 main.foo
xxx/trace.go 20 main.boom
xxx/trace.go 24 main.main
/usr/local/Cellar/go/1.11.2/libexec/src/runtime/proc.go 210 runtime.main
/usr/local/Cellar/go/1.11.2/libexec/src/runtime/asm_amd64.s 1334 runtime.goexit

runtime.CallersFrames(callers []uintptr) *runtime.Frames

runtime.CallersFrames可以一次解析多个pc

 8
 9
10
11
12
13
14
15
16
17
18
19


func foo() {
 pc := make([]uintptr, 10)
 n := runtime.Callers(1, pc)
 frames := runtime.CallersFrames(pc[:n])

 var frame runtime.Frame
 more := n > 0
 for more {
 frame, more = frames.Next()
 fmt.Printf("%s %d %s\n", frame.File, frame.Line, frame.Function)
 }
}

func runtime.FuncForPC(pc uintptr) *runtime.Func

前面使用了runtime.FuncForPC来解析pc，获得函数信息。

它返回的*runtime.Func主要有三个方法：

Entry() uintptr: 返回函数入口地址（函数注释Entry address of the function）
Name() string: 返回函数名
FileLine(pc uintptr) (file string, line int): 返回文件名和行号

LeetCode 85. Maximal Rectangle

Wed, 12 Dec 2018 11:42:17 +0800

Description

Maximal Rectangle

Given a 2D binary matrix filled with 0’s and 1’s, find the largest rectangle containing only 1’s and return its area.

Example:

1
2
3
4
5
6
7
8


Input:
[
 ["1","0","1","0","0"],
 ["1","0","1","1","1"],
 ["1","1","1","1","1"],
 ["1","0","0","1","0"]
]
Output: 6

在给出的矩阵中，1表示元素，0表示空，找出最大矩形的面积。

Solution

本题可以利用《84. Largest Rectangle in Histogram》
的代码。

下面来看看如何转换成 84 题的直方图求解问题：

 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


矩阵：
 [10100]
 [10111]
 [11111]
 [10010]

第一行，将 0 及其上方元素去掉：
 [1 1 ]

第二行，将 0 及其上方元素去掉：
 [1 1 ]
 [1 111]

第三行，将 0 及其上方元素去掉：
 [1 1 ]
 [1 111]
 [11111]

第四行，将 0 及其上方元素去掉：
 [1 ]
 [1 1 ]
 [1 1 ]
 [1 1 ]

通过四次转换，其实得到四个直方图：
[10100]、[20211]、[31322]、[4030]

至此已将矩阵问题转换成了之前的直方图问题。使用相应代码求解即可。

下面largestRectangleArea的代码点击这里查看。

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


func maximalRectangle(matrix [][]byte) int {
 h := len(matrix)
 if h == 0 {
 return h
 }
 w := len(matrix[0])

 max := 0
 heights := make([]int, w)
 for j := 0; j < h; j++ {
 for i := 0; i < w; i++ {
 if matrix[j][i] == '1' {
 heights[i]++
 } else {
 heights[i] = 0
 }
 }
 max = maxInt(max, largestRectangleArea(heights))
 }

 return max
}

LeetCode 84. Largest Rectangle in Histogram

Tue, 11 Dec 2018 10:10:38 +0800

Description

Largest Rectangle in Histogram

Given n non-negative integers representing the histogram’s bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

给出一个直方图，求最大矩形面积。

Solution

首先假设直方图是升序的，比如：1, 3, 5, 6, 7

那么需要比较的面积有：1*5，3 * 4，5*3，6*2，7*1。

计算公式为：$ S(i) = height[i] * (length-i) $

所以最大面积：$ \max_{i=0}^n{S(i)} $

那遇到无序的数组怎么办呢？

根据提示可以是用栈，目的是用于构造升序数组：

假设当前高度为h：

如果升序则直接入栈
遇到降序，将栈中所有比h高的都利用公式计算出面积，然后降低它们的高度至h，使数组重新有序

例如数组1, 3, 4, 2, 3：

 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


^
| 0
| 00 0
| 0000
| 00000
.------->

首先：1，3，4 都是升序，依次入栈（下标入栈）：
^
| 0 stack:
| 00 [2]
| 00 [1]
| 000 [0]
.------->

遇到：2，不符合升序，计算前面 3 和 4 的面积分别为：S(1)=3*2，S(2)=4*1
然后降低高度至 2
^
| stack: 将 4 的下标出栈，保留 3 的下标（因为 3 所在位置是新高度的起点）
|
| 000 [1]
| 0000 [0]
.------->

遇到：3，符合升序，直接入栈
^
| stack:
| 0 [4]
| 0000 [1]
| 00000 [0]
.------->

最后仍需要计算的面积有：S(0)=1*5，S(1)=2*4，S(4)=3*1

所以最大面积为 8

 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


func maxInt(a, b int) int {
 if a > b {
 return a
 }
 return b
}

func largestRectangleArea(heights []int) int {
 stack := make([]int, 0)
 lenStack := len(stack)
 max := 0

 // 追加一个 -1，用于最后清空栈
 heights = append(heights, -1)

 for i := 0; i < len(heights); i++ {
 h := heights[i]

 if lenStack > 0 && h < heights[stack[lenStack-1]] {
 // 如果前面更高，将更高的都出栈
 // 同时计算面积，然后降低它们的高度（形成新的“有序”）
 for {
 idx := stack[lenStack-1]
 // 计算面积
 max = maxInt(max, heights[idx]*(i-idx))
 // 降低高度
 heights[idx] = h

 lenStack-- // 假出栈
 if lenStack == 0 || h > heights[stack[lenStack-1]] {
 // 最后一个，保留在栈中作为新高度的起点
 lenStack++
 break
 }
 stack = stack[:lenStack]
 }
 } else /* 这个判断可有可无 if lenStack == 0 || h > heights[stack[lenStack-1]] */ {
 // 将当前索引入栈
 stack = append(stack, i)
 lenStack++
 }
 }

 return max
}

LeetCode 82. Remove Duplicates From Sorted List II

Mon, 10 Dec 2018 15:30:20 +0800

Description

Remove Duplicates from Sorted List II

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

Example 1:
1
2
Input: 1->2->3->3->4->4->5
Output: 1->2->5
Example 2:
1
2
Input: 1->1->1->2->3
Output: 2->3

删除链表中有重复的结点

Solution

 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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
 public:
 ListNode* deleteDuplicates(ListNode* head) {
 if (head == NULL) {
 return NULL;
 }

 auto h = ListNode(0);
 h.next = head;

 auto *p1 = &h;
 auto *p2 = p1->next;
 auto *cur = p2->next;

 while (cur) {
 if (cur->val == p2->val) {
 // 循环移除重复的结点
 do {
 cur = cur->next;
 }while(cur && cur->val == p2->val);

 p1->next = cur; // 然后移除p2指向的结点（p1->next == p2）
 if (!cur) {
 break;
 }
 } else {
 p1 = p2; // (p1 = p1->next)
 }

 p2 = cur;
 cur = cur->next;
 }

 return h.next;
 }
};

LeetCode 81. Search in Rotated Sorted Array II

Mon, 10 Dec 2018 14:34:14 +0800

Description

Search in Rotated Sorted Array II

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).

You are given a target value to search. If found in the array return true, otherwise return false.

Example 1:
1
2
Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true
Example 2:
1
2
Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false
Follow up:

This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.

Would this affect the run-time complexity? How and why?

Solution

 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:
 bool search(const std::vector<int>& nums, int target) {
 int l = 0;
 int r = nums.size() - 1;
 int mid, lnum, mnum, rnum;

 while (l <= r) {
 mid = l + (r - l)/2;

 lnum = nums.at(l);
 mnum = nums.at(mid);
 rnum = nums.at(r);

 // 一次判断三个数
 if (mnum == target || lnum == target || rnum == target) {
 return true;
 } else if (lnum < mnum) {
 // lnum < mnum 表示左边有序，那么判断target是否落在左边
 if (target < mnum && target >= lnum) {
 r = mid - 1;
 } else {
 l = mid + 1;
 }
 } else if (rnum > mnum) {
 // rnum > mnum 表示右边有序，那么判断target是否落在右边
 if (target > mnum && target <= rnum) {
 l = mid + 1;
 } else {
 r = mid - 1;
 }
 } else {
 // 收紧区域
 r--, l++;
 }
 }

 return false;
 }
};

LeetCode 80. Remove Duplicates from Sorted Array II

Thu, 06 Dec 2018 09:33:43 +0800

Description

Remove Duplicates from Sorted Array II

Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:
1
2
3
4
5
6
Given nums = [1,1,1,2,2,3],

Your function should return length = 5, with the first five elements
of nums being 1, 1, 2, 2 and 3 respectively.

It doesn't matter what you leave beyond the returned length.
Example 2:
1
2
3
4
5
6
Given nums = [0,0,1,1,1,1,2,3,3],

Your function should return length = 7, with the first seven elements
of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.

It doesn't matter what values are set beyond the returned length.

在有序数组中删除重复的元素，每个元素允许重复一次（出现两次）。

Solution

 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


func removeDuplicates(nums []int) int {
 length := len(nums)
 if length <= 2 {
 return length
 }

 readPointer, writePointer := 0, 0
 for readPointer < length {
 // 写入一次
 nums[writePointer] = nums[readPointer]
 writePointer++
 readPointer++

 if readPointer >= length {
 break
 }

 // 如果存在一个相同的，则再写入一次
 // 然后跳过后面重复的数字
 if nums[readPointer] == nums[writePointer-1] {
 nums[writePointer] = nums[readPointer]
 writePointer++
 readPointer++

 // 跳过重复的
 for readPointer < length && nums[readPointer] == nums[writePointer-1] {
 readPointer++
 }
 }
 }

 return writePointer
}

LeetCode 79. Word Search

Wed, 05 Dec 2018 14:29:27 +0800

Description

Word Search

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


board =
[
 ['A','B','C','E'],
 ['S','F','C','S'],
 ['A','D','E','E']
]

Given word = "ABCCED", return true.
Given word = "SEE", return true.
Given word = "ABCB", return false.

在board中查找是否存在相连（相邻）的字符与给定的单词对应。

很像一个走迷宫的题目，搜索下一步是否与单词的字母匹配，是则走到该位置。

Solution

 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


func exist(board [][]byte, word string) bool {
 height := len(board)
 if height == 0 {
 return false
 }

 width := len(board[0])
 if width == 0 {
 return false
 }

 w := []byte(word)
 wLength := len(w)

 var solve func(x, y, wordIndex int) bool
 solve = func(x, y, wordIndex int) bool {
 // 单词搜索完毕
 if wordIndex >= wLength {
 return true
 }

 // 边界检查
 if x >= width || x < 0 {
 return false
 }
 if y >= height || y < 0 {
 return false
 }

 // 检查当前格是否匹配
 if board[y][x] != w[wordIndex] {
 return false
 }

 // 修改当前格，避免重复搜索
 tmp := board[y][x]
 board[y][x] = byte(0)

 // 搜索下一格
 ok := solve(x-1, y, wordIndex+1) ||
 solve(x, y-1, wordIndex+1) ||
 solve(x+1, y, wordIndex+1) ||
 solve(x, y+1, wordIndex+1)

 // 还原当前格
 board[y][x] = tmp

 return ok
 }

 for i := 0; i < height; i++ {
 for j := 0; j < width; j++ {
 if solve(j, i, 0) {
 return true
 }
 }
 }

 return false
}

LeetCode 78. Subsets

Wed, 05 Dec 2018 11:03:48 +0800

Description

Subsets

Given a set of distinct integers, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

Input: nums = [1,2,3]
Output:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[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



求所有子集（幂集），包含一个空集。





## Solution


### 回溯（Backtracking）

与上一题[《LeetCode 77. Combinations》](/leetcode/077-combinations/)
的思路相似

可以递归回溯，分别找出`k`从`0->len(nums)`的所有组合。

### 位运算（Bit Manipulation）

设长度`l = len(nums)`，设有一个`l`位二进制数`flag`，每一位对应`nums`中的一个数字。

如果这一位为`1`，表示对应数字显示；为`0`表示隐藏。

那么`flag`的所有二进制组合可以对应`nums`的所有子集

很容易得到：$ flag \in [0, 2^l) $

比如题目中的例子：

nums = [1, 2, 3]

when flag=0 b(000) => []
when flag=1 b(001) => [ , , 3]
when flag=2 b(010) => [ , 2, ]
when flag=3 b(011) => [ , 2, 3]
when flag=4 b(100) => [1, , ]
when flag=5 b(101) => [1, , 3]
when flag=6 b(110) => [1, 2, ]
when flag=7 b(111) => [1, 2, 3]

1
2
3
4
5
6
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


func subsets(nums []int) [][]int {
 l := len(nums)

 // power: 2^l
 n := 1 << uint(l)

 result := [][]int{}

 for i := 0; i < n; i++ {
 // each bit means a number in []nums
 // if the bit is 1, the number is visible
 // else the number is invisible
 flag := i

 r := []int{}
 for j := 0; j < l; j++ {
 // check if this number visible
 if flag&0x01 > 0 {
 r = append(r, nums[j])
 }
 // right-shift
 flag >>= 1
 }

 result = append(result, r)
 }

 return result
}



## Similar Problem

- [90. Subsets II](/leetcode/090-subsets-ii/)

LeetCode 77. Combinations

Mon, 03 Dec 2018 08:56:03 +0800

Description

Combinations

Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

Example:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Input: n = 4, k = 2
Output:
[
 [2,4],
 [3,4],
 [2,3],
 [1,2],
 [1,3],
 [1,4],
]

给出两个整数n和k，输出所有包含k个数字的组合，数字范围1..n。

Solution

224 ms, faster than 97.50%

 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


func combine(n int, k int) [][]int {
 result := [][]int{}

 // C(n, k)
 minK := k
 if n-k < minK {
 minK = n - k
 }
 p, c := 1, 1
 for i := 0; i < minK; i++ {
 c *= minK - i
 p *= n - i
 }
 c = p / c

 // 一次性申请内存，+k额外用于递归时存放
 memo := make([]int, c*k+k)

 // 前面k个用于递归时使用，结果从第k+1个开始
 start := k

 var solve func(n, kk int)
 solve = func(it, kk int) {
 if kk == k-1 {
 for it < n {
 it++
 memo[kk] = it

 r := memo[start : start+k]
 copy(r, memo)
 result = append(result, r)

 start += k
 }
 } else {
 for it < n {
 it++
 memo[kk] = it
 solve(it, kk+1)
 }
 }
 }

 solve(0, 0)

 return result
}

LeetCode 76. Minimum Window Substring

Fri, 30 Nov 2018 10:53:51 +0800

Description

Minimum Window Substring

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

Example:
1
2
Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"
Note:

If there is no such window in S that covers all characters in T, return the empty string “”.

If there is such window, you are guaranteed that there will always be only one unique minimum window in S.

给出两个字符串S和T，在S中找到一个最短的子串，它包含T中所有的字符。

需要注意的是的是T中一个字符会出现多次，在子串同样需要多次。

Solution

设两个指针表示子串的首尾：left，right：
right向右移动扩展子串，直到子串包含T：
left向右移动收缩子串，直到最短满足T，记录子串：
left再次右移，这时子串不再满足包含T：
right从重复第二步骤，找到新的子串：
再次收缩子串，与之前的子串比较是否更短：

之前是使用map来做记录，需要26ms，后来第一名使用数组记录更快，可以跑进4ms。

 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


func minWindow(s string, t string) string {
 m := make([]int, 128)
 // 记录有多少个不同的字符
 espect := 0

 // 每次遇到一个字符就减一
 // 在后面遍历的时候加一，遇到等于0表示当前字符恰好满足数量
 for _, v := range []byte(t) {
 if m[v] == 0 {
 espect++
 }
 m[v]--
 }

 arrayS := []byte(s)

 minStart, minLength := 0, math.MaxInt32
 okCnt := 0
 l, r := 0, 0

 tightenLeft := func() {
 // 收紧左边
 for okCnt == espect {
 v := arrayS[l]
 l++
 m[v]--

 // 小于0表示当前字符是需求的字符，且数量已经不满足
 if m[v] < 0 {
 okCnt--

 length := r - l + 2
 if length < minLength {
 minLength, minStart = length, l-1
 }

 break
 }
 }
 }

 // 向右扩展
 for r < len(arrayS) {
 v := arrayS[r]
 m[v]++

 // 等于0表示当前字符是需求的字符，且数量恰好满足
 if 0 == m[v] {
 okCnt++
 tightenLeft()
 }
 r++
 }

 if minLength != math.MaxInt32 {
 return string(arrayS[minStart : minStart+minLength])
 }
 return ""
}

LeetCode 75. Sort Colors

Thu, 29 Nov 2018 10:50:23 +0800

Description

Sort Colors

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not suppose to use the library’s sort function for this problem.

Example:
1
2
3
Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]
Follow up:
A rather straight forward solution is a two-pass algorithm using counting sort.

First, iterate the array counting number of 0’s, 1’s, and 2’s, then overwrite array with total number of 0’s, then 1’s and followed by 2’s.

Could you come up with a one-pass algorithm using only constant space?

对一个只包含0、1、2三个数字的数组进行排序，要求时间复杂度O(n)，空间复杂度O(1)。

Solution

 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


func sortColors(nums []int) {
 length := len(nums)
 if length <= 1 {
 return
 }

 l, r := 0, length-1

 // 记录 0（红色）的数量
 red := 0

 for l <= r {
 fmt.Println(nums[l])
 switch nums[l] {
 case 0:
 if l != red {
 // 将第 red 个和第 l 个交换
 // 因为 red 表示 0 的数量，所以第 red 个应该是被跳过的 1
 nums[l], nums[red] = nums[red], nums[l]
 }
 red++
 fallthrough
 case 1:
 // 遇到 1 （白色）则跳过
 l++
 case 2:
 // 遇到 2 （蓝色）则交换到末尾，并且 r--，l 不动
 nums[r], nums[l] = nums[l], nums[r]
 r--
 }
 }
}

LeetCode 74. Search a 2D Matrix

Wed, 28 Nov 2018 15:07:51 +0800

Description

Search a 2D Matrix

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted from left to right.

The first integer of each row is greater than the last integer of the previous row.

Example 1:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
Input:
matrix = [
 [1, 3, 5, 7],
 [10, 11, 16, 20],
 [23, 30, 34, 50]
]

target = 3
Output: true

target = 13
Output: false

矩阵中有序存地放着一些数字，查找是否存在某个数字。

Solution

二分法（Binary Search）

下面代码使用两次二分查找，先找出在哪一行，再对该行进行二分查找。

亦有先计算元素个数：total = m x n，再对total进行二分查找的解法。
设二分时所以为index，对应元素坐标为(index/m, index%m)。

 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


func searchMatrix(matrix [][]int, target int) bool {
 l, r := 0, len(matrix)-1

 // 先二分查找在哪一行
 for l < r {
 m := r - (r-l)/2

 if target >= matrix[m][0] {
 l = m
 } else {
 r = m - 1
 }
 }

 // conner case
 if l > len(matrix)-1 {
 return false
 }

 row := matrix[l]
 l, r = 0, len(row)-1

 // 再在对应行中进行二分查找
 for l <= r {
 m := l + (r-l)/2

 if target == row[m] {
 return true
 }

 if target > row[m] {
 l = m + 1
 } else {
 r = m - 1
 }
 }

 return false
}

LeetCode 73. Set Matrix Zeroes

Wed, 28 Nov 2018 14:33:12 +0800

Description

Set Matrix Zeroes

Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in-place.
Example 1:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
Input:
[
 [1,1,1],
 [1,0,1],
 [1,1,1]
]
Output:
[
 [1,0,1],
 [0,0,0],
 [1,0,1]
]
Example 2:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
Input:
[
 [0,1,2,0],
 [3,4,5,2],
 [1,3,1,5]
]
Output:
[
 [0,0,0,0],
 [0,4,5,0],
 [0,3,1,0]
]
Follow up:

A straight forward solution using O(mn) space is probably a bad idea.

A simple improvement uses O(m + n) space, but still not the best solution.

Could you devise a constant space solution?

在m x n的矩阵中，如果一个元素为0，则将它所在的行和列都置为0。

Solution

要解决只使用O(1)空间问题，根据提示可以使用第一行和第一列暂存标记，最后再将对应的行和列置 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
58
59
60
61
62
63
64


func setZeroes(matrix [][]int) {
 // 用于保存第一行和第一列是否需要置0
 firstRow, firstCol := false, false

 row := len(matrix)
 col := len(matrix[0])

 // 检查第一列是否有0
 for i := 0; i < row; i++ {
 if matrix[i][0] == 0 {
 firstCol = true
 break
 }
 }
 // 检查第一行是否有0
 for i := 0; i < col; i++ {
 if matrix[0][i] == 0 {
 firstRow = true
 }
 }

 for i := 1; i < row; i++ {
 for j := 1; j < col; j++ {
 if matrix[i][j] == 0 {
 // 使用第一列标记当前行需要置0
 matrix[i][0] = 0
 // 使用第一行标记当前列需要置0
 matrix[0][j] = 0
 }
 }
 }

 // 检查第一列的标记
 for i := 1; i < row; i++ {
 if matrix[i][0] == 0 {
 for j := 1; j < col; j++ {
 matrix[i][j] = 0
 }
 }
 }

 // 检查第一行的标记
 for j := 1; j < col; j++ {
 if matrix[0][j] == 0 {
 for i := 1; i < row; i++ {
 matrix[i][j] = 0
 }
 }
 }

 // 将第一列置0
 if firstCol {
 for i := 0; i < row; i++ {
 matrix[i][0] = 0
 }
 }

 // 将第一行置0
 if firstRow {
 for i := 0; i < col; i++ {
 matrix[0][i] = 0
 }
 }
}

LeetCode 72. Edit Distance

Tue, 27 Nov 2018 10:51:41 +0800

Description

Edit Distance

Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.

You have the following 3 operations permitted on a word:

Insert a character

Delete a character

Replace a character

Example 1:

Input: word1 = “horse”, word2 = “ros”
Output: 3
Explanation:
horse -> rorse (replace ‘h’ with ‘r’)
rorse -> rose (remove ‘r’)
rose -> ros (remove ’e’)

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


>
> **Example 2:**
>
> ```
Input: word1 = "intention", word2 = "execution"
Output: 5
Explanation:
intention -> inention (remove 't')
inention -> enention (replace 'i' with 'e')
enention -> exention (replace 'n' with 'x')
exention -> exection (replace 'n' with 'c')
exection -> execution (insert 'u')

Solution

设最短距离方法为f：

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


反推：

f("horse", "ros") = 1 + min(f("hors", "ros"), // 删除 hors[e]
 f("horse", "ro"), // 插入 ro[s]
 f("hors", "ro")) // 替换 hors[e] ro[s]

f("hors", "ros") = 1 + min(f("hor", "ros"), // 删除 hor[s]
 f("hors", "ro"), // 插入 ro[s]
 f("hor", "ro")) // 替换 hor[s] ro[s]
...

特殊情况和边界条件：
如果最后一个字符相同，则不用操作，distance = 0
如果其中一个字符串为空，则 distance = 另一个字符串长度

解释：

删除hors[e]：通过f("hors", "ros")将hors变成ros，则有rose删除最后一位得到ros
插入ro[s]：通过f("horse", "ro")将horse变成ro，则插入一位s得到ros
替换替换 hors[e] ro[s]：通过f("hors", "ro")将hors变成ro，则有roe替换最后一位得到ros

递归（Recursive）

 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


func min(a, b int) int {
 if a < b {
 return a
 }
 return b
}
func min3(a, b, c int) int {
 return min(min(a, b), c)
}

func minDistance(word1, word2 string) int {
 w1, w2 := []byte(word1), []byte(word2)

 l1, l2 := len(w1), len(w2)

 cache := make([][]int, l1)
 for i := 0; i < l1; i++ {
 cache[i] = make([]int, l2)
 }

 var solve func(int, int) int
 solve = func(l1, l2 int) int {
 if l1 == 0 || l2 == 0 {
 return l1 + l2
 }

 idx1, idx2 := l1-1, l2-1

 if cache[idx1][idx2] >= 1 {
 // 缓存减一后返回
 return cache[idx1][idx2] - 1
 }

 var r int
 if w1[idx1] == w2[idx2] {
 // 末位相等
 r = solve(l1-1, l2-1)
 } else {

 r = 1 + min3(solve(l1-1, l2), // 删除
 solve(l1, l2-1), // 插入
 solve(l1-1, l2-1)) // 替换
 }

 // 避免需要初始化成`-1`
 // 加一后缓存
 cache[idx1][idx2] = r + 1

 return r
 }

 return solve(l1, l2)
}

动态规划（Dynamic Programming）

 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


func minDistance(word1 string, word2 string) int {
 l1, l2 := len(word1), len(word2)

 if l1 == 0 || l2 == 0 {
 return l1 + l2
 }

 matrix := make([][]int, l1+1)
 for i := 0; i <= l1; i++ {
 matrix[i] = make([]int, l2+1)
 matrix[i][0] = i
 }
 for i := 0; i <= l2; i++ {
 matrix[0][i] = i
 }

 w1, w2 := []byte(word1), []byte(word2)
 for i := 1; i <= l1; i++ {
 for j := 1; j <= l2; j++ {
 if w1[i-1] == w2[j-1] {
 matrix[i][j] = matrix[i-1][j-1]
 } else {
 matrix[i][j] = 1 + min3(matrix[i-1][j-1],
 matrix[i][j-1],
 matrix[i-1][j])
 }
 }
 }

 return matrix[l1][l2]
}

LeetCode 70. Climbing Stairs

Mon, 26 Nov 2018 09:11:58 +0800

Description

Climbing Stairs

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Note: Given n will be a positive integer.

Example 1:
1
2
3
4
5
Input: 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps
Example 2:
1
2
3
4
5
6
Input: 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

好像网上讲动态规划经常举例的题目。

爬楼梯，可以一次爬一格或者两格，问有多少种不同的方式爬到顶。

Solution

与《63. Unique Paths II》非常相似。

到达第n格可以通过第n-1格爬一格和第n-2格爬两格，两种方式达到。

所以有：

$$ f(n) = f(n-1) + f(n-2) $$

动态规划（Dynamic Programming）

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


func climbStairs(n int) int {
 steps := []int{0, 1, 2}
 if n <= 2 {
 return steps[n]
 }

 for i := 2; i < n; i++ {
 // tmp := steps[2]
 // steps[2] = steps[1] + steps[2]
 // steps[1] = tmp
 steps[1], steps[2] = steps[2], steps[1]+steps[2]
 }

 return steps[2]
}

递归（Recursive）

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


func climbStairs(n int) int {
 // f(n) = f(n-1) + f(n-2)
 // f(n-1) = f(n-2) + f(n-3)
 // 为了避免计算两次f(n-2) 增加缓存
 m := map[int]int{1: 1, 2: 2}

 var solve func(int) int
 solve = func(n int) int {
 if num, ok := m[n]; ok {
 return num
 }
 m[n] = solve(n-1) + solve(n-2)
 return m[n]
 }
 return solve(n)
}

LeetCode 69. Sqrt(x)

Fri, 23 Nov 2018 14:51:19 +0800

Description

Sqrt(x)

Implement int sqrt(int x).

Compute and return the square root of x, where x is guaranteed to be a non-negative integer.

Since the return type is an integer, the decimal digits are truncated and only the integer part of the result is returned.

Example 1:
1
2
Input: 4
Output: 2
Example 2:
1
2
3
4
Input: 8
Output: 2
Explanation: The square root of 8 is 2.82842..., and since
 the decimal part is truncated, 2 is returned.

整型“开方”

根据题意，mySqrt(x) = floor(sqrt(x))

Solution

使用二分法进行查找

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


func mySqrt(x int) int {
 if x == 0 {
 return 0
 }
 left, right := 1, x/2

 for left < right {
 m := right - (right-left)/2
 if m*m > x {
 right = m - 1
 } else {
 left = m
 }
 }

 return left
}

LeetCode 68. Text Justification

Fri, 23 Nov 2018 14:26:13 +0800

Description

Text Justification

Given an array of words and a width maxWidth, format the text such that each line has exactly maxWidth characters and is fully (left and right) justified.

You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces ' ' when necessary so that each line has exactly maxWidth characters.

Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.

For the last line of text, it should be left justified and no extra space is inserted between words.

Note:

A word is defined as a character sequence consisting of non-space characters only.

Each word’s length is guaranteed to be greater than 0 and not exceed maxWidth.

The input array words contains at least one word.

Example 1:

1
2
3
4
5
6
7
8
9


Input:
words = ["This", "is", "an", "example", "of", "text", "justification."]
maxWidth = 16
Output:
[
 "This is an",
 "example of text",
 "justification. "
]

Example 2:

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


Input:
words = ["What","must","be","acknowledgment","shall","be"]
maxWidth = 16
Output:
[
 "What must be",
 "acknowledgment ",
 "shall be "
]
Explanation: Note that the last line is "shall be " instead of "shall be",
 because the last line must be left-justified instead of fully-justified.
 Note that the second line is also left-justified becase it contains only one word.

Example 3:

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


Input:
words = ["Science","is","what","we","understand","well","enough","to","explain",
 "to","a","computer.","Art","is","everything","else","we","do"]
maxWidth = 20
Output:
[
 "Science is what we",
 "understand well",
 "enough to explain to",
 "a computer. Art is",
 "everything else we",
 "do "
]

Solution

 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


func fullJustify(words []string, maxWidth int) []string {
 buildLine := func(end, lineLen int) string {
 // 只有一个单词
 if end == 1 {
 return words[0] + strings.Repeat(" ", maxWidth-lineLen)
 }

 space := maxWidth - lineLen
 for i := 0; space > 0; space-- {
 words[i%(end-1)] += " "
 i++
 }

 return strings.Join(words[:end], "")
 }

 result := []string{}
 curLen, wordLen := 0, 0
 for i := 0; i < len(words); i++ {
 wordLen = len(words[i])

 // i 表示单词个数减一，等于单词之间单个空格数量
 if i+curLen+wordLen > maxWidth {
 result = append(result, buildLine(i, curLen))
 i, curLen, words = 0, wordLen, words[i:]
 } else {
 curLen += wordLen
 }
 }

 // build last line
 lastLine := strings.Join(words, " ")
 if len(lastLine) < maxWidth {
 lastLine += strings.Repeat(" ", maxWidth-len(lastLine))
 }

 result = append(result, lastLine)

 return result
}

LeetCode 66. Plus One & 67. Add Binary

Fri, 23 Nov 2018 09:54:07 +0800

Plus One

Description

Plus One

给定一个用数组表示的十进制数，将数字加一。

Example 1:

1
2
3


Input: [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123.

Example 2:

1
2
3


Input: [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321.

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


func plusOne(digits []int) []int {
 for i := len(digits) - 1; i >= 0; i-- {
 if digits[i] != 9 {
 digits[i]++
 return digits
 }
 digits[i] = 0
 }

 return append([]int{1}, digits...)
}

Add Binary

Discription

Add Binary

将两个二进制字符串相加

Example 1:

1
2


Input: a = "11", b = "1"
Output: "100"

Example 2:

1
2


Input: a = "1010", b = "1011"
Output: "10101"

Solution

 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


func addBinary(a string, b string) string {
 aLen := len(a)
 bLen := len(b)

 limit := aLen
 if bLen > limit {
 limit = bLen
 }

 s := make([]byte, limit+1)

 var carry byte
 var idx int
 for i := 1; i <= limit; i++ {
 idx = aLen - i
 if idx >= 0 {
 carry += a[idx] - '0'
 }

 idx = bLen - i
 if idx >= 0 {
 carry += b[idx] - '0'
 }

 // 因为 s 长度为 limit+1，所以需要 limit-i+1
 s[limit-i+1] = carry&0x01 + '0'
 carry >>= 1
 }

 // 起初 s 申请的长度为 limit：make([]byte, limit)
 // 然后判断 carry 为 1 的时候 s = append([]byte{'1'}, s...)
 // 这样导致第二次申请内存，耗时增加
 // 所以直接申请 limit + 1 长度，返回时少返回一位
 if carry == 0 {
 return string(s[1:])
 }

 s[0] = '1'

 return string(s)
}

LeetCode 64. Minimum Path Sum

Thu, 22 Nov 2018 14:44:37 +0800

Description

Minimum Path Sum

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Example:
1
2
3
4
5
6
7
8
Input:
[
 [1,3,1],
 [1,5,1],
 [4,2,1]
]
Output: 7
Explanation: Because the path 1→3→1→1→1 minimizes the sum.

每个格子的数字表示经过它所需的消耗大小。寻找从左上到右下的最少路径消耗。

Solution

似曾相识

本题与《63. Unique Paths II》
使用相同的方法：

要到达右下角，需要经过左边或者上边的格子，而最少消耗自然是从这两个格子中选择到达它们所需消耗（非它们自身消耗）较少的一个：

$$ f(x, y) = cost_{(x,y)} + min(f(x-1, y), f(x, y-1)) $$

所以与之前一样，从左上开始往右下分别计算出每个格子的最少消耗，直到最终格子。

Code Here

 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


func minPathSum(grid [][]int) int {
 row := len(grid)
 if row == 0 {
 return 0
 }

 col := len(grid[0])
 if col == 0 {
 return 0
 }

 var left, up, minCost, upCost int

 // 从第二个格子开始
 j := 1
 for i := 0; i < row; i++ {
 for ; j < col; j++ {
 minCost = -1

 left = j - 1
 if left >= 0 {
 // 左边消耗
 minCost = grid[i][left]
 }

 up = i - 1
 if up >= 0 {
 // 上边消耗
 upCost = grid[up][j]
 if upCost < minCost || minCost == -1 {
 minCost = upCost
 }
 }

 // 选择较少消耗的路径并加上自身消耗
 // 保存当前格子消耗
 grid[i][j] += minCost
 }
 j = 0
 }

 // 返回最后一个格子消耗
 return grid[row-1][col-1]
}

LeetCode 63. Unique Paths II

Thu, 22 Nov 2018 09:06:11 +0800

Description

Unique Paths II

A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

Note: m and n will be at most 100.

Example 1:

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


Input:
[
 [0,0,0],
 [0,1,0],
 [0,0,0]
]
Output: 2
Explanation:
There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right

给出地图，求左上角到右下角的路径数量（只能向下或向右移动）。

其中地图中1表示障碍，无法通过。

Solution

动态规划（Dynamic Programming）

要到达最后一个格子，只能通过它左边和上边两个格子到达，
那么达到它的路径数量等于到达左边和上边两个格子的路径数量相加。

依此类推，到达左边和上边两个格子的路径数量又分别等于它们的左边和上边两条路径之和。

最终我们将反推到第一个格子，它的路径数量只有一条。

其中第一排和第一列稍微特殊，它们只有一条路径可以到达。

所以当前格子路径数量：

$$ f(x, y) = f(x-1, y) + f(x, y-1) $$

通过这个公式可以写出对应的递归方法。

更简便的方法是从左上方格子开始，向后计算每个格子的路径数量，直到最后一个格子。

Example

比如地图4x3的地图，将第一个格子路径数量标记为1，然后依次标记后边的格子，得到达到最后一个格子的路径数量为10：

1
2
3


0, 0, 0, 0 1, 1, 1, 1
0, 0, 0, 0 ==> 1, 2, 3, 4
0, 0, 0, 0 1, 3, 6, 10

现在假设有一个障碍，只需要在遇到障碍时，将障碍的路径数量标记为0即可：

1
2
3


0, 0, 0, 0 1, 1, 1, 1
0, 0, 1, 0 ==> 1, 2, 0, 1
0, 0, 0, 0 1, 3, 3, 4

Code Here

 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


func uniquePathsWithObstacles(obstacleGrid [][]int) int {
 row := len(obstacleGrid)
 if row == 0 {
 return 0
 }

 col := len(obstacleGrid[0])
 if col == 0 || obstacleGrid[0][0] == 1 {
 return 0
 }

 var left, up int
 var ways int

 // 标记第一格到达路径数量为1
 obstacleGrid[0][0] = 1
 j := 1 // 从第二个格子开始
 for i := 0; i < row; i++ {
 for ; j < col; j++ {
 // 如果为障碍，标记当前格子达到路径数量为 0
 if obstacleGrid[i][j] == 1 {
 obstacleGrid[i][j] = 0
 continue
 }

 // 表示当前格子到达路径数量
 // 它等于左边格子路径数量+上边格子路径数量
 ways = 0

 left = j - 1
 if left >= 0 {
 // 加上左边格子路径数量
 // ways += leftWays
 ways = obstacleGrid[i][left]
 }

 up = i - 1
 if up >= 0 {
 // 加上上边格子路径数量
 ways += obstacleGrid[up][j]
 }

 // 保存当前格子路径数量
 obstacleGrid[i][j] = ways
 }
 j = 0
 }

 // 返回最后一个格子路径数量
 return obstacleGrid[row-1][col-1]
}

LeetCode 50. Pow(x, n)

Wed, 21 Nov 2018 15:27:28 +0800

Description

Pow(x, n)

Implement pow(x, n), which calculates x raised to the power n (x^n).

Example 1:
1
2
Input: 2.00000, 10
Output: 1024.00000
Example 2:
1
2
Input: 2.10000, 3
Output: 9.26100
Example 3:
1
2
3
Input: 2.00000, -2
Output: 0.25000
Explanation: 2^{-2} = {1/2}^2 = 1/4 = 0.25
Note:

-100.0 < x < 100.0

n is a 32-bit signed integer, within the range [−2^31, 2^31 − 1]

求x的n次方。

Solution

使用分治法将n次方分解为n/2次方问题。

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


func myPow(x float64, n int) float64 {
 if x == 0 || x == 1 {
 return x
 } else if n == 0 {
 return 1
 } else if n < 0 {
 return myPow(1/x, -n)
 } else if n&1 == 0 {
 return myPow(x*x, n/2)
 } else {
 return x * myPow(x*x, n/2)
 }
}

LintCode 1630. Interesting String

Tue, 20 Nov 2018 09:53:28 +0800

Description

There is now a string s consisting of only numbers and lowercase letters.

If the string s is interesting, then s must be split into several substrings, each substring satisfies the beginning of the number, and the number represents the number of characters after it. For example, s = “4g12y6hunter”, we can divide it into “4g12y” and “6hunter”, so the string is interesting.

If s is an interesting string, output “yes”, otherwise output “no”

Example:

s = "124gray6hunter",return "yes"
1
we can divide it into "12", "4gray", "6hunter".
s = "31ba2a" ,return "no"

判断字符串s是否“有趣”。

有趣：字符串可以被分成多组，每组前面的数字等于剩余字符的长度。

Solution

本题主要在于需要识别连续数字，比如11需要理解为十一。

使用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
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


<!-- tab golang -->
func check(s string) string {
 sLength := len(s)

 if sLength <= 0 {
 return "no"
 }

 queue := []int{0}

 var idx, n, num, nextIdx int
 for len(queue) > 0 {
 // pop front
 idx = queue[0]
 queue = queue[1:]

 n = 0
 for idx < sLength {
 num = int(s[idx] - byte('0'))
 if num < 0 || num > 9 {
 break
 }
 n = n*10 + num

 // 从当前位置向后跳过 n 个字符
 // 并且检查下一个字符是否为数字或者恰好结束
 nextIdx = idx + n + 1

 if nextIdx > sLength {
 break
 } else if nextIdx == sLength {
 // 当前位置恰好结束
 return "yes"
 } else if nextIdx != idx {
 // push back
 queue = append(queue, nextIdx)
 }
 idx++
 }
 }

 return "no"
}
<!-- endtab -->

<!-- tab cpp -->
class Solution {
public:
 /**
 * @param s: the string s
 * @return: check if the string is interesting
 */
 string check(string &s) {
 // Write your code here
 int sLength = s.length();
 if (sLength == 0) {
 return "no";
 }

 queue<int> q;
 q.push(0);

 int idx, n, num, nextIdx;
 while (q.size() > 0) {
 // pop front
 int idx = q.front();
 q.pop();

 n = 0;
 for (; idx < sLength; idx++) {
 num = s[idx] - (int)'0';
 if (num < 0 || num > 9) {
 break;
 }

 n = n*10 + num;

 // 从当前位置向后跳过 n 个字符
 // 并且检查下一个字符是否为数字或者恰好结束
 nextIdx = idx + n + 1;

 if (nextIdx > sLength) {
 break;
 } else if (nextIdx == sLength) {
 // 当前位置恰好结束
 return "yes";
 } else if (nextIdx != idx) {
 // push back
 q.push(nextIdx);
 }
 }
 }

 return "no";
 }
};
<!-- endtab -->

LeetCode 61. Rotate List

Mon, 19 Nov 2018 14:37:06 +0800

Description

Rotate List

Given a linked list, rotate the list to the right by k places, where k is non-negative.

Example 1:

1
2
3
4
5


Input: 1->2->3->4->5->NULL, k = 2
Output: 4->5->1->2->3->NULL
Explanation:
rotate 1 steps to the right: 5->1->2->3->4->NULL
rotate 2 steps to the right: 4->5->1->2->3->NULL

Example 2:

1
2
3
4
5
6
7


Input: 0->1->2->NULL, k = 4
Output: 2->0->1->NULL
Explanation:
rotate 1 steps to the right: 2->0->1->NULL
rotate 2 steps to the right: 1->2->0->NULL
rotate 3 steps to the right: 0->1->2->NULL
rotate 4 steps to the right: 2->0->1->NULL

从倒数第k个结点位置旋转链表：首尾相连，以倒数第k个结点为新head。

Solution

这种寻找链表倒数第k的方法，通常使用快慢指针。

快指针先前进k个结点，然后两个指针同时前进，当到快指针达链表尾部时，
两个指针相差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


func rotateRight(head *ListNode, k int) *ListNode {
 if head == nil || k == 0 {
 return head
 }

 fast := &ListNode{
 Next: head,
 }
 slow := fast

 // fast 先前进
 steps := 0
 for steps < k {
 fast = fast.Next
 steps++
 if fast.Next == nil {
 k = k % steps
 if k == 0 {
 return head
 }
 steps = 0
 fast = slow
 }
 }

 // 再同时前进
 for fast.Next != nil {
 fast = fast.Next
 slow = slow.Next
 }

 fast.Next = head
 head = slow.Next
 slow.Next = nil

 return head
}

LeetCode 60. Permutation Sequence

Mon, 19 Nov 2018 10:52:29 +0800

Description

Permutation Sequence

The set [1,2,3,...,n] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order, we get the following sequence for n = 3:

"123"

"132"

"213"

"231"

"312"

"321"

Given n and k, return the k-th permutation sequence.

Note:

Given n will be between 1 and 9 inclusive.

Given k will be between 1 and n! inclusive.

Example 1:
1
2
Input: n = 3, k = 3
Output: "213"
Example 2:
1
2
Input: n = 4, k = 9
Output: "2314"

假设存在长度为n的数组：[1,2,3,...,n]，输出第k个排列。

Solution

一个长度为n的数组，总共有n!种排列。假设第一个数字固定后，剩余(n-1)!种排列。

上图中的字典序树可以更直观的看出，
在n=4:[1,2,3,4]中，
“第零层”包含4!=24个叶子，
第一层包含3!=6个叶子，
第二层包含2!=2个叶子…

假设现在要查找第k=9个排列（第九个叶子），第一层应该经过第⌈9/3!⌉ 个分支，即ceil(k/(n-1)!)。

由此公式，可以依次求每层分支序号。
比如k=9，依次经过：

⌈9 / 3!⌉: 2
⌈9-3!*(2-1) / 2!⌉: 2
[9-3!*(2-1)-2!*(2-1) / 1!]: 1
1

通过序号：2,2,1,1所经过的分支，可以得到结果：2314

 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


func getPermutation(n int, k int) string {
 s := []rune{}

 total := 1

 for i := 1; i <= n; i++ {
 total *= i
 s = append(s, rune(i)+rune('0'))
 }

 ret := make([]rune, n)
 idx := 0
 for n > 0 {
 // (n-1)!
 total /= n

 // 当前层索引
 i := (k - 1) / total

 // 移除 s[i]
 ret[idx] = s[i]
 s = append(s[:i], s[i+1:]...)

 // 减去前面组的数量，得到下一层的索引
 k -= total * i
 idx++
 n--
 }

 return string(ret)
}

使用元表优化 Lua 配置文件 II

Fri, 16 Nov 2018 11:38:00 +0800

上回提到元表优化 Lua 配置文件，以减少重复字段，节省内存开销。

除了这种直接地减少内存开销的方法，使用元表还能实现数据的延迟加载，从另一个角度节约内存。

延迟加载

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


-- PropModel.lua
PropModel = {
 [1001] = {
 ID = 1001,
 name = "道具1001",
 desc = "道具1001描述",
 ...
 },
 [1002] = {
 ID = 1002,
 name = "道具1002",
 desc = "道具1002描述",
 ...
 },
 ...
}

上面依然是最常见的道具表，所有道具都配置在同一个表中，初始化时会全部加载进内存。
然而大多数道具是玩家并不拥有的，在内存中长期停留浪费空间。

通过使用元表，我们能做到每个道具按需（延迟）加载。

首先清空表数据，使用元表的__index方法实现延迟加载：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


-- PropModel.lua
PropModel = {} -- 道具表不再直接存放数据

-- 使用元表延迟加载数据
setmetatable(PropModel, {
 __index = function(t, k)
 local item = require(string.format("PropModel_%s", k))
 PropModel[k] = item
 return item
 end,
})

将各道具数据另外存放——将道具1001单独存放：

1
2
3
4
5
6
7
8


-- PropModel_1001.lua
local PropModel_1001 = {
 ID = 1001,
 name = "道具1001",
 desc = "道具1002描述",
 ...
}
return PropModel_1001

最后

上面的代码是每个item单独拆分到一个文件中。
如果有必要，也可以按照ID进行区间拆分，将多个item放在一个文件中。
在__index方法中判断ID落在哪个区间，将该区间数据全部加载。

同时，拆分后的数据依然可以结合上一篇
的“默认字段”的方法使用。

LeetCode 59. Spiral Matrix II

Fri, 16 Nov 2018 08:54:44 +0800

Description

Spiral Matrix II

Given a positive integer n, generate a square matrix filled with elements from 1 to n^2 in spiral order.

Example:
1
2
3
4
5
6
7
Input: 3
Output:
[
 [ 1, 2, 3 ],
 [ 8, 9, 4 ],
 [ 7, 6, 5 ]
]

Solution

This problem is very similar to 54. Spiral Matrix.

Just replace function append_ans to mark_idx:

1
2
3
4
5


idx := 1
mark_idx := func(x, y int) {
 matrix[x][y] = idx
 idx++
}

LeetCode 58. Length of Last Word

Fri, 16 Nov 2018 08:35:56 +0800

Description

Length of Last Word

Given a string s consists of upper/lower-case alphabets and empty space characters ’ ‘, return the length of last word in the string.

If the last word does not exist, return 0.

Note: A word is defined as a character sequence consists of non-space characters only.

Example:
1
2
Input: "Hello World"
Output: 5

求给出的字符串中最后一个单词的长度。

Solution

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


func lengthOfLastWord(s string) int {
 length := 0
 for i := len(s) - 1; i >= 0; i-- {
 if s[i] == ' ' {
 // if there are spaces at last, they'll be skip
 if length > 0 {
 break
 }
 } else {
 // there are only alphabets and space
 // so it's alphabets now
 // we don't need to check if s[i] between 'a' to 'z' or 'A' to 'Z'
 length++
 }
 }

 return length
}

LeetCode 57. Insert Interval

Thu, 15 Nov 2018 16:31:58 +0800

Description

Insert Interval

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
1
2
Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]
Example 2:
1
2
3
Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
Output: [[1,2],[3,10],[12,16]]
Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].

在给出的有序区间中插入新的区间，需要合并相邻的区间。

Solution

先找出所有比新区间小的区间
再找出所有比新区间大的区间
在查找过程中将新区间与相邻区间合并
最后返回[小区间]+[新区间]+[大区间]

 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


func insert(intervals []Interval, newInterval Interval) []Interval {
 length := len(intervals)
 if length == 0 {
 return []Interval{newInterval}
 }

 // 分割比 newInterval 小的区间
 lEnd := 0
 for lEnd < length && newInterval.Start > intervals[lEnd].End {
 lEnd++
 }

 // 边界判断
 if lEnd == length {
 return append(intervals, newInterval)
 }

 if intervals[lEnd].Start < newInterval.Start {
 // 将当前区间与 newInterval 合并
 newInterval.Start = intervals[lEnd].Start
 }

 // 分割比 newInterval 大的区间
 rStart := lEnd
 for rStart < length && newInterval.End >= intervals[rStart].Start {
 if intervals[rStart].End > newInterval.End {
 // 将当前区间与 newInterval 合并
 newInterval.End = intervals[rStart].End
 }
 rStart++
 }

 // append 时用 newInterval 建立新的 Slice 与 intervals[rStart:] 合并
 // 再与 intervals[:lEnd] 合并
 // 之前直接将 newInterval append 到 intervals[:lEnd] 后面，再与 intervals[rStart:] 合并
 // 会导致 intervals[rStart:] 的内存区域被覆盖
 return append(intervals[:lEnd], append([]Interval{newInterval}, intervals[rStart:]...)...)
}

LeetCode 56. Merge Intervals

Thu, 15 Nov 2018 14:49:19 +0800

Description

Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

Example 1:

1
2
3


Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].

Example 2:

1
2
3


Input: [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considerred overlapping.

合并区间重叠/相邻的区间。

Solution

先对区间进行排序，然后逐个判断是否需要与前一个区间合并。

 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


/**
 * Definition for an interval.
 * type Interval struct {
 * Start int
 * End int
 * }
 */
type IntervalArr []Interval

func (h IntervalArr) Len() int {
 return len(h)
}
func (h IntervalArr) Less(i, j int) bool {
 return h[i].Start < h[j].Start
}
func (h IntervalArr) Swap(i, j int) {
 h[i], h[j] = h[j], h[i]
}

func merge(intervals []Interval) []Interval {
 if len(intervals) == 0 {
 return nil
 }

 // 先对区间进行排序
 sort.Sort(IntervalArr(intervals))

 ret := make([]Interval, 0)
 pInter := &intervals[0]

 for i := 1; i < len(intervals); i++ {
 curInter := &intervals[i]

 if pInter.End >= curInter.Start {
 if pInter.End < curInter.End {
 // “合并操作”
 pInter.End = curInter.End
 }
 } else {
 ret = append(ret, *pInter)
 pInter = curInter
 }
 }

 ret = append(ret, *pInter)

 return ret
}

LeetCode 55. Jump Game

Thu, 15 Nov 2018 11:29:11 +0800

Description

Jump Game

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

Example 1:
1
2
3
Input: [2,3,1,1,4]
Output: true
Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
Example 2:
1
2
3
4
Input: [3,2,1,0,4]
Output: false
Explanation: You will always arrive at index 3 no matter what. Its maximum
 jump length is 0, which makes it impossible to reach the last index.

给定一个非负整型数组，每个数字表示可以从该位置向后跳跃的最大步数。

判断是否能从第一个数字开始跳跃到最后一个数字。

Solution

使用reachable表示当前可跳跃的最远位置；
从第一个位置开始向reachable搜索，并更新reachable；
如果reachable >= len(nums) - 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


func canJump(nums []int) bool {
 target := len(nums) - 1

 if target < 0 {
 return false
 }

 // 可到达的最远距离
 reachable := 0

 // 从 0 到 reachable
 for i := 0; i <= reachable; i++ {
 m := nums[i] + i
 if m > reachable {
 reachable = m
 }

 if reachable >= target {
 return true
 }
 }

 return reachable >= target
}

LeetCode 54. Spiral Matrix

Thu, 15 Nov 2018 10:43:41 +0800

Description

Spiral Matrix

Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

Example 1:
1
2
3
4
5
6
7
Input:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
Output: [1,2,3,6,9,8,7,4,5]
Example 2:
1
2
3
4
5
6
7
Input:
[
 [1, 2, 3, 4],
 [5, 6, 7, 8],
 [9,10,11,12]
]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]

从外向内螺旋形遍历矩阵。

Solution

列出遍历的四方边界：left，right，top，bottom；
每次循环时，边界向中间收紧。

在循环中，分别遍历上边，右边，底边，左边。

 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


func spiralOrder(matrix [][]int) []int {
 // 矩阵有效性判断
 row := len(matrix)
 if row == 0 {
 return nil
 }
 col := len(matrix[0])
 if col == 0 {
 return nil
 }

 res := make([]int, row*col)
 idx := 0

 append_ans := func(x, y int) {
 res[idx] = matrix[x][y]
 idx++
 }

 // 边界：left, right, top, bottom
 l, r := 0, col-1
 t, b := 0, row-1

 for l <= r && t <= b {
 // 从左往右遍历top行
 for i := l; i <= r; i++ {
 append_ans(t, i)
 }

 // 从上往下遍历right列
 for i := t + 1; i < b; i++ {
 append_ans(i, r)
 }

 if t < b {
 // 从右往左遍历bottom行
 for i := r; i >= l; i-- {
 append_ans(b, i)
 }
 }

 if l < r {
 // 从下往上遍历left列
 for i := b - 1; i > t; i-- {
 append_ans(i, l)
 }
 }

 // 收紧边界
 l++
 r--
 t++
 b--
 }

 return res
}

使用元表优化 Lua 配置文件

Tue, 06 Nov 2018 15:14:38 +0800

配置文件

在游戏工程中，通常有大量配置是由策划提供，再转换成程序方便读取的格式添加到工程中。

在我参与的Cocos2dx-Lua工程中，策划通常在Excel中配置，再通过脚本转换为Lua-Table的文件。

比如常见的道具表转换后：

 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


-- PropModel.lua
PropModel = {
 [1001] = {
 ID = 1001,
 name = "道具1001",
 desc = "道具1001描述",
 colorLv = 1, -- 颜色等级
 ifSell = true, -- 是否可以出售
 ifUse = true, -- 是否可以使用
 useExtraStr = "", -- 使用时额外消耗的资源
 useNeedNum = 1, -- 使用消耗数量
 maxNum = 99, -- 最大堆叠数量
 ...
 },
 [1002] = {
 ID = 1002,
 name = "道具1002",
 desc = "道具1002描述",
 colorLv = 1, -- 颜色等级
 ifSell = true, -- 是否可以出售
 ifUse = true, -- 是否可以使用
 useExtraStr = "", -- 使用时额外消耗的资源
 useNeedNum = 1, -- 使用消耗数量
 maxNum = 99, -- 最大堆叠数量
 ...
 },
 ...
}

Excel配置中每一行数据经过转换后对应Lua-Table的一个item。

通过观察可以发现其中有部分字段很容易重复，如：colorLv、ifUse、useNeedNum等，
这些字段通常为枚举或者有固定的分类，只有几个不同的值，然而配置表中每个item都需要为这些内容创建一个字段。

优化

有了这些重复的字段，就给了我们优化的空间。
通过使用Lua的元表，可以让每个item拥有共同的字段而非每个item去创建一个字段。
从而节省内存开销。

如优化之后：

 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


PropModel = {
 [1001] = {
 ID = 1001,
 name = "道具1001",
 desc = "道具1001描述",
 ...
 },
 [1002] = {
 ID = 1002,
 name = "道具1002",
 desc = "道具1002描述",
 ...
 },
 ...
}

-- 将重复内容提取为默认item
local default__ = {
 colorLv = 1,
 ifSell = true,
 ifUse = true,
 useExtraStr = "",
 useNeedNum = 1,
 maxNum = 99,
}

local base = {
 __index = default__,
}
for _, v in pairs(PropModel) do
 setmetatable(v, base)
end

这样为每个item设置元表后，item中的字段数量大幅缩减。

在实际生产中，这步优化被直接放在脚本中进行。在Excel到Lua-Table的过程中直接完成。

缺点

可读性变差。开发人员人工检查时需要把数据对应的item和default__组合起来看才能得到当前item的数据。

LeetCode 62. Unique Paths

Mon, 10 Sep 2018 14:43:03 +0800

Description

Unique Paths

A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).

How many possible unique paths are there?

Above is a 7 x 3 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

Example 1:

1
2
3
4
5
6
7


Input: m = 3, n = 2
Output: 3
Explanation:
From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
1. Right -> Right -> Down
2. Right -> Down -> Right
3. Down -> Right -> Right

Example 2:

1
2


Input: m = 7, n = 3
Output: 28

在m x n的方格中，从左上角走到右下角的不同路径有几种？（只允许向右和向下走）

Solution

这道题目可以转换为数学题：

m x n的方格要从左上角走到右下角，需要经过m - 1次Right和n - 1次Down操作。
所以总共是m + n - 2次操作，而操作顺序的不同，则对应路径不同。

这就转换成了数学的排列问题：C(m + n -2, n - 1)。
在m + n - 2操作中取Down操作的位置，其余位置就是Right操作。

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


func uniquePaths(m int, n int) int {
 total := (m + n - 2)
 option := n - 1

 // C(3, 1) 与 C(3, 2)相等
 if m-1 < option {
 option = m - 1
 }

 if option <= 0 {
 return 1
 }

 // 计算C(m + n - 2, option)
 pp, qq := 1, 1
 for i := 1; i <= option; i++ {
 pp *= total
 qq *= i
 total--
 }

 return pp / qq
}

CGO —— Golang 与 C 语言混合编程

Mon, 03 Sep 2018 15:56:08 +0800

C 语言与 Golang 相互调用的简单例子。

在此使用一段简单的代码展示 CGO 的基本用法 —— 在 Go 程序中使用 C 语言编程。

使用 C 源码编译

项目目录结构：

1
2
3
4
5
6


project/
 - main.go
 - add/
 - add.h
 - add.c
 - add.go

在 add.h、add.c 中，分别定义已经实现了两数相加的函数 add：

1
2


// add.h
int add(int a, int b);

1
2
3
4
5
6


// add.c
#include "add.h"

int add(int a, int b) {
 return a + b;
}

在 add.go 中，对 C 语言实现的函数 add 进行了一次封装，以便外部调用：

 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


package add

/*
#include "add.h"
#include <stdio.h>
#include <stdlib.h>

int mul(int a, int b) {
 return a * b;
}
*/
import "C"

import (
 "unsafe"
)

func HelloWorld() {
 s := C.CString("Hello World!")
 C.puts(s)
 C.free(unsafe.Pointer(s))
}

func Add(a, b int) int {
 return int(C.add(C.int(a), C.int(b)))
}

func Mul(a, b int) int {
 return int(C.mul(C.int(a), C.int(b)))
}

其中的 import "C" 表示使用了 CGO 。在这条语句前面的注释是一段 C 语言代码。
这里就定义了哪些 C 语言函数被引用。也可以在这里直接编写函数并实现。
~~因为这个特殊的语法，import “C” 必须单独一行，不可与其他包一起引用。~~
可以看到在代码中引用了头文件 add.h 以及 C 标准库的头文件，另外还实现了另一个两数相乘的函数 mul。

在 Golang 中通过使用 C.xxx 的方式调用 C 函数。HelloWorld 展示了对库函数的调用。Add 和 Mul 展示了对自定义函数的调用。

因为Golang 和 C 有各自的变量类型。所以传参时候需要进行类型转换。

HelloWorld 在传参时使用 C.CString 将 Golang 字符串类型转换为 C 语言类型。
因为 C.CString 是在堆上分配空间存放字符串，需要调用者自己释放，所以最后调用 C.free 释放该字符串。

点击这里获取更多类型转换的知识。

最后在 main.go 中引用 add 包：

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


package main

import (
 "fmt"

 // import package add
 "./add"
)

func main() {
 add.HelloWorld()
 fmt.Println(add.Add(10, 5))
 fmt.Println(add.Mul(10, 5))
}

编译运行后可以看到输出：

1
2
3


Hello World!
15
50

其中 add.c 因为 import ./add 的引用而参与编译。

使用链接库

除了可以直接使用 C 源码编译 Go 程序，还可以：

调用 C 导出的静态库/动态库
把 Golang 编译成静态库/动态库供 C 其他程序调用。

点击这里获取另外几种调用方式演示代码

参考

更多 CGO 知识可以从这里获取

govendor 使用

Thu, 02 Aug 2018 14:43:33 +0800

govendor

go vendor 是 go 1.6 官方正式引入的包管理方式。

其基本思路是，将引用的外部包的源代码放在当前工程的vendor目录下面，go 编译时会优先从vendor目录寻找依赖关系。

包状态类型

首先要知道govendor对包状态的分类：

状态	缩写	含义
+local	l	packages in your project 本地包，即项目自身的包组织
+external	e	被引用、在$GOPATH下找得到、但当前项目不存在的包
+vendor	v	已被 govendor 管理，即在 vendor 目录下
+std	s	标准库中的包
+excluded	x	明确从vendoring中排除的外部包
+unused	u	未使用的包，即包在 vendor 目录下，但项目并没有用到
+missing	m	代码引用了依赖包，但该包并没有找到
+program	p	主程序包，意味着可以编译为执行文件
+outside		+external +missing
+all		所有的包

常用的三种为：

external: 放在$GOPATH 下被依赖的包（最常用）
local: 项目自身的包
vendor: 被govendor管理的，放在vendor目录下的包

命令

命令	功能
init	初始化 vendor 目录
list	列出所有的依赖包
add	添加包到 vendor 目录，如 govendor add +external 添加所有外部包，也可以直接跟包名，如 govendor add golang.org/x/net/internal/socket
update	从 $GOPATH 更新依赖包到 vendor 目录
remove	从 vendor 管理中删除依赖（add 的反操作）
status	列出所有缺失、过期和修改过的包
fetch	添加或更新包到本地 vendor 目录
sync	本地存在 vendor.json 时候拉去依赖包，匹配所记录的版本
get	类似 go get 目录，拉取依赖包到 vendor 目录

基本操作

govendor status: 查看当前包状态

govendor list +e: 查看当前项目的依赖但是未被添加到vendor中的包

govendor add +e: 添加依赖的包。如果vendor.json中存在，但是vendor目录下不存在（即govendor status显示缺失）的包也会被重新添加

govendor remove +u: 删除在vendor下但是未依赖的包

在实际过程中，有部分包是团队的公共包。
这部分包通常有自己的单独项目，并且已经被我们添加到$GOPATH下，可能就不需要添加到当前项目的vendor下。

这时候可以结合list和add来使用，
先用list -no-status +e列出依赖包，然后使用grep过滤，再调用add命令添加：

1

govendor list -no-status +e | grep -v 'myteam/common' | xargs govendor add

go get through a proxy

Thu, 02 Aug 2018 09:47:52 +0800

由于众所不知的原因，在国内访问golang.org需要爬梯子。

所以使用go get安装某些包的时候，也要用梯子。

方法

1. 设置 git 代理

1

git config --global http.proxy socks5://127.0.0.1:9527

2. 通过代理 go get

socks5 代理：

1

http_proxy=socks5://127.0.0.1:9527 go get golang.org/x/tools/cmd/goimports

3. 取消 git 代理

1

git config --global --unset http.proxy

http 代理

如果是 http 代理，将socks5://改为http://

LeetCode 41. First Missing Positive

Fri, 27 Jul 2018 08:59:07 +0800

First Missing Positive

Description

Given an unsorted integer array, find the smallest missing positive integer.

Example 1:
1
2
Input: [1,2,0]
Output: 3
Example 2:
1
2
Input: [3,4,-1,1]
Output: 2
Example 3:
1
2
Input: [7,8,9,11,12]
Output: 1
Note:

Your algorithm should run in O(n) time and uses constant extra space.

使用O(n)的时间复杂度和O(1)的空间在无序数组中查找第一个缺失的正数。

Solution

此题关键在于利用数字直接寻找其位置，达到排序目的。

假设有数组[4, 3, 5, 1]：

取第一个数4，检查4是否在第4个位置：否，与第四个位置数字交换得到[1, 3, 5, 4]。

交换后继续判断当前数字1是否在第1个位置：是，则跳过。

依次判断之后得到数组[1, 5, 3, 4]。其中遇到5时因为其超过数组长度，直接跳过。

再次从第一个位置开始判断，找到第一个位置与数字不符合的地方即为缺失的数字。

 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


func firstMissingPositive(nums []int) int {
 l := len(nums)

 // 进行排序
 for i := 0; i < l; {
 n := nums[i]

 if n <= 0 || n > l {
 // 溢出的不用管
 i++
 } else if i+1 != n && nums[n-1] != n {
 // 判断当前数字是否在它应该的位置上
 // 数字 n 应该在[n - 1]上
 // 需要处理目标位置与当前位置数字相同，否则死循环
 nums[i] = nums[n-1]
 nums[n-1] = n
 // 交换位置后，继续处理当前位置上的数字，不需要i++
 } else {
 // 处理下一个位置
 i++
 }
 }

 // 查找第一个不符合的数字
 for i := 0; i < l; i++ {
 if nums[i] != i+1 {
 return i + 1
 }
 }

 return l + 1
}

LeetCode 43. Multiply Strings

Thu, 26 Jul 2018 15:35:19 +0800

Multiply Strings

Description

Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2, also represented as a string.

Example 1:

Input: num1 = “2”, num2 = “3”
Output: “6”

Example 2:

Input: num1 = “123”, num2 = “456”
Output: “56088”

将两个字符串表示的数字相乘（大数相乘）。

Note:

The length of both num1 and num2 is < 110.

Both num1 and num2 contain only digits 0-9.

Both num1 and num2 do not contain any leading zero, except the number 0 itself.

You must not use any built-in BigInteger library or convert the inputs to integer directly.

实现大数相乘：以string的形式给出两个非负整数，求乘积。

Solution

我在实现这个乘法时，按照手写计算的方式，每次按位相乘之后记录进位然后写下当前位。
然后把当前位结果加上前一位的结果并存为byte。每次外循环都会做一次大数加法，将乘积结果累加。
效率很不理想：40ms。

在看了别人的算法之后，重新实现了一遍。

先将每一位的乘法结果保存，最后再按位相加并处理进位。

这里贴出别人的算法：

 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


func multiply(num1 string, num2 string) string {
 l1, l2 := len(num1), len(num2)

 // 需要使用int，使用byte会在按位相加的时候溢出
 r := make([]int16, l1+l2)

 idx := 0
 for i1 := l1 - 1; i1 >= 0; i1-- {
 // num1的个位数从最后一位开始写；
 // num1的十位数从倒数第二位开始写；
 // num2的百位数从倒数第三位开始写
 // ...
 // so: l1 + l2 - 1 - (l1 - i1 - 1)
 idx = l2 + i1
 for i2 := l2 - 1; i2 >= 0; i2-- {
 r[idx] += int16(num1[i1]-'0') * int16(num2[i2]-'0')
 idx--
 }
 }

 // 按位相加并进位
 for idx = len(r) - 1; idx >= 0; idx-- {
 if r[idx] > 9 {
 r[idx-1] += (r[idx] / 10)
 r[idx] %= 10
 }
 }


 var buf bytes.Buffer
 // truncate front '0'
 for _, v := range r {
 if buf.Len() > 0 || v != 0 {
 buf.WriteByte(byte(v) + '0')
 }
 }

 if buf.Len() == 0 {
 buf.WriteByte('0')
 }

 return buf.String()
}

LeetCode 40. Combination Sum II

Thu, 26 Jul 2018 10:39:33 +0800

Combination Sum II

Description

Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sums to target.

Each number in candidates may only be used once in the combination.

Note:

All numbers (including target) will be positive integers.
The solution set must not contain duplicate combinations.

Example 1:

1
2
3
4
5
6
7
8


Input: candidates = [10,1,2,7,6,1,5], target = 8,
A solution set is:
[
 [1, 7],
 [1, 2, 5],
 [2, 6],
 [1, 1, 6]
]

Example 2:

1
2
3
4
5
6


Input: candidates = [2,5,2,1,2], target = 5,
A solution set is:
[
 [1,2,2],
 [5]
]

Solution

与上一篇 Combination Sum 几乎一毛一样。只是多了一步去重操作。

 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


func combinationSum2(candidates []int, target int) [][]int {
 sort.Ints(candidates)

 return doCombinationSum(candidates, target)
}

func doCombinationSum(candidates []int, target int) [][]int {
 res := [][]int{}

 if len(candidates) == 0 {
 return res
 }

 t := target - candidates[0]

 if t == 0 {
 res = append(res, []int{candidates[0]})
 } else if t > 0 {
 res = doCombinationSum(candidates[1:], t)
 for i, v := range res {
 res[i] = append([]int{candidates[0]}, v...)
 }
 }

 // 为了去重
 for len(candidates) > 1 && candidates[0] == candidates[1] {
 candidates = candidates[1:]
 }

 res = append(res, doCombinationSum(candidates[1:], target)...)

 return res
}

LeetCode 39. Combination Sum

Thu, 26 Jul 2018 10:16:53 +0800

Combination Sum

Description

Given a set of candidate numbers (candidates) (without duplicates) and a target number (target), find all unique combinations in candidates where the candidate numbers sums to target.

The same repeated number may be chosen from candidates unlimited number of times.

Note:

All numbers (including target) will be positive integers.

The solution set must not contain duplicate combinations.

Example 1:

1
2
3
4
5
6


Input: candidates = [2,3,6,7], target = 7,
A solution set is:
[
 [7],
 [2,2,3]
]

Example 2:

1
2
3
4
5
6
7


Input: candidates = [2,3,5], target = 8,
A solution set is:
[
 [2,2,2,2],
 [2,3,3],
 [3,5]
]

给出加数与和数，求出所有组合。

Solution

思路是与之前做过的查找解的题目相似：
把target减去候选数，得到剩余target，继续查找，直到target为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


func combinationSum(candidates []int, target int) [][]int {
 sort.Ints(candidates)

 return doCombinationSum(candidates, target)
}

func doCombinationSum(candidates []int, target int) [][]int {
 res := [][]int{}

 if len(candidates) == 0 {
 return res
 }

 t := target - candidates[0]

 if t < 0 {
 return res
 } else if t == 0 {
 res = append(res, []int{candidates[0]})
 } else if t > 0 {
 res = doCombinationSum(candidates, t)
 for i, v := range res {
 res[i] = append([]int{candidates[0]}, v...)
 }
 }

 res = append(res, doCombinationSum(candidates[1:], target)...)

 return res
}

LeetCode 36. Valid Sudoku

Thu, 26 Jul 2018 09:22:05 +0800

Valid Sudoku

Description

Determine if a 9x9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

Each row must contain the digits 1-9 without repetition.

Each column must contain the digits 1-9 without repetition.

Each of the 9 3x3 sub-boxes of the grid must contain the digits 1-9 without repetition.

A partially filled sudoku which is valid.

The Sudoku board could be partially filled, where empty cells are filled with the character '.'.

验证数独

Example 1:

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


Input:
[
 ["5","3",".",".","7",".",".",".","."],
 ["6",".",".","1","9","5",".",".","."],
 [".","9","8",".",".",".",".","6","."],
 ["8",".",".",".","6",".",".",".","3"],
 ["4",".",".","8",".","3",".",".","1"],
 ["7",".",".",".","2",".",".",".","6"],
 [".","6",".",".",".",".","2","8","."],
 [".",".",".","4","1","9",".",".","5"],
 [".",".",".",".","8",".",".","7","9"]
]
Output: true

Example 2:

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


Input:
[
 ["8","3",".",".","7",".",".",".","."],
 ["6",".",".","1","9","5",".",".","."],
 [".","9","8",".",".",".",".","6","."],
 ["8",".",".",".","6",".",".",".","3"],
 ["4",".",".","8",".","3",".",".","1"],
 ["7",".",".",".","2",".",".",".","6"],
 [".","6",".",".",".",".","2","8","."],
 [".",".",".","4","1","9",".",".","5"],
 [".",".",".",".","8",".",".","7","9"]
]
Output: false

Explanation: Same as Example 1, except with the 5 in the top left corner being modified to 8.
Since there are two 8's in the top left 3x3 sub-box, it is invalid.

Note:

A Sudoku board (partially filled) could be valid but is not necessarily solvable.
Only the filled cells need to be validated according to the mentioned rules.
The given board contain only digits 1-9 and the character ‘.’.
The given board size is always 9x9.

判断数独板是否有效。

注：

一个数组板可以是有效但是无解的。

Solution

根据题意只需要判断数独板中给出的数字在行列和3x3格子中是否有重复即可。而不需要判断是否可以解。

 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


func isValidSudoku(board [][]byte) bool {
 // 用于标记第x列已使用的数字
 colUsed := [9][9]bool{}
 // 用于标记3x3小方格已使用的数字
 subBoxUsed := [3][3][9]bool{}

 for row := 0; row < 9; row++ {
 // 用于标记当前行已使用的数字
 rowUsed := [9]bool{}

 for col := 0; col < 9; col++ {
 b := board[row][col]
 if b == '.' {
 continue
 }

 num := b - '0' - 1

 // 检查数字是否已使用
 if rowUsed[num] || colUsed[col][num] || subBoxUsed[row / 3][col / 3][num] {
 return false
 }

 // 标记为已使用
 rowUsed[num] = true
 colUsed[col][num] = true
 subBoxUsed[row / 3][col / 3][num] = true
 }
 }

 return true
}

LeetCode 33. Search in Rotated Sorted Array

Wed, 25 Jul 2018 14:28:45 +0800

Search in Rotated Sorted Array

Description

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Your algorithm’s runtime complexity must be in the order of O(log n).

Example 1:

1
2


Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

1
2


Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

假设有一个升序的数组，但是从某处出现了旋转。
要在此数组中查找给定值，并且时间复杂度为O(log n)。

Solution

此题为二分查找法的一个变形：

跟二分查找法一样，先找出中间数，判断是否命中。

如果未命中，则根据大小判断是落在左边还是右边。

当我们找出中间数之后，需要确定哪一边是完全升序的数组。然后判断目标是否落在该区域，以决定接下来在哪边进行查找。

 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


// 递归写法
func search(nums []int, target int) int {
 if len(nums) == 0 {
 return -1
 }

 mid := len(nums) / 2

 if nums[mid] == target {
 return mid
 }

 search_right := func() int {
 r := search(nums[mid:], target)
 if r == -1 {
 return -1
 }
 return mid + r
 }

 search_left := func() int {
 return search(nums[:mid], target)
 }

 // 判断左边是否有序
 if nums[0] < nums[mid] {
 // 左边有序时判断是否在左边范围
 if target >= nums[0] && target <= nums[mid] {
 return search_left()
 }

 return search_right()
 } else {
 // 右边有序时判断是否在右边范围
 if target >= nums[mid] && target <= nums[len(nums) - 1] {
 return search_right()
 }

 return search_left()
 }
}

LeetCode 32. Longest Valid Parentheses

Wed, 25 Jul 2018 09:56:49 +0800

Longest Valid Parentheses

Description

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

Example 1:
1
2
3
Input: "(()"
Output: 2
Explanation: The longest valid parentheses substring is "()"
**Example 2:**
``` Input: ")()())" Output: 4 Explanation: The longest valid parentheses substring is "()()" ```

输出最长的左右括号匹配的子串长度

Solution

逐个字符扫描并记录左右括号长度，当左右括号数量相等时，左右括号达到全匹配。

如果只从左往右扫描，"((()"这种左括号多于右括号的会被判断为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


func longestValidParentheses(s string) int {
 longest := 0

 left, right := 0, 0
 check_longest := func() {
 // 如果左右相等则此时左右括号匹配
 if left == right {
 if left * 2 > longest {
 longest = left * 2
 }
 }
 }

 // 从左往右扫描
 for i := 0; i < len(s); i++ {
 if s[i] == '(' {
 left++
 } else {
 right++

 // 右括号多于左括号，则不满足连续匹配规则，需要重置
 if right > left {
 left, right = 0, 0
 continue
 }
 }

 check_longest()
 }

 left, right = 0, 0

 // 从右往左扫描
 for i := len(s) - 1; i >= 0; i-- {
 if s[i] == '(' {
 left++

 // 左括号多于右括号，则不满足连续匹配规则
 if left > right {
 left, right = 0, 0
 continue
 }
 } else {
 right++
 }


 check_longest()
 }

 return longest
}

LeetCode 31. Next Permutation

Thu, 19 Jul 2018 10:17:07 +0800

Next Permutation

Description

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

1,2,3 → 1,3,2

3,2,1 → 1,2,3

1,1,5 → 1,5,1

实现字典序排列的 nextPermutation 方法，假如已经是最大排列，则输出最小排列。

字典序排列

我们在字符串大小比较时，就已经使用了字典序:

例如：abc < abcd < abde < afab

所以字典序排列算法中有：

最小排列：1-n，eg：1,2,3,4
最大排列：n-1，eg：4,3,2,1
next-permutation：根据当前排列，生成恰好比它大的下一个排列

通过字典序树可以更好的理解：

Solution

参考 wikipedia 中关于字典序排列的算法描述：

Find the largest index k such that a[k] < a[k + 1]. If no such index exists, the permutation is the last permutation.

Find the largest index l greater than k such that a[k] < a[l].

Swap the value of a[k] with that of a[l].

Reverse the sequence from a[k + 1] up to and including the final element a[n].

假设当前排列为长度为n+1的数组a，则其下一个排列的算法为:

查找最大的索引k，满足a[k] < a[k + 1]。如果不存在则当前已经是最大排列。
查找最大索引l，满足l > k && a[k] < a[l]。
交换a[k]和a[l]
将a[k + 1], a[k + 2], ..., a[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


func nextPermutation(nums []int) {
 length := len(nums)
 if length == 1 {
 return
 }

 k := length - 2
 for ; k >= 0; k-- {
 if nums[k] < nums[k+1] {
 break
 }
 }

 if k == -1 {
 // 当前已经是最大排列，则输出最小排列
 reverse(nums)
 return
 }

 l := length - 1
 for ; l > k; l-- {
 if nums[l] > nums[k] {
 break
 }
 }

 // 交换 a[k] 和 a[l]
 swap(nums, k, l)

 // 倒序 a[k]...a[n]
 reverse(nums[k+1:])
}

// 交换两个数
func swap(nums []int, i, j int) {
 tmp := nums[i]
 nums[i] = nums[j]
 nums[j] = tmp
}

// 将slice倒序
func reverse(nums []int) {
 length := len(nums)
 for i := 0; i < length / 2; i++ {
 swap(nums, i, length - i - 1)
 }
}

Golang Slice and Array

Mon, 25 Jun 2018 15:22:42 +0800

数组与切片

以前粗学时并没有留意 Golang 的数组，一直以为只有切片。

今天看《Go 语言实践》时才发现 Golang 也有数组。与切片的区别是定义时指定长度（例如长度为 4 的 int 型数组var array [4]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


package main

import "fmt"

func main() {
// 定义数组 a1
a1 := [4]int{1, 2, 3, 4}

 // 数组 a2 来自 a1 的拷贝
 a2 := a1

 var a3 [4]int
 a3 = a1 // 同样会完整拷贝

 // a2 修改自己的内存区域
 a2[0] = 0

 // 切片 s1 来自 a1，其空间仍由 a1 实现
 s1 := a1[1:2]
 // 修改切片 s1 会影响数组 a1
 s1 = append(s1, -1, -2)

 fmt.Println("a1:", a1)
 fmt.Println("a2:", a2)
 fmt.Println("a3:", a3)
 fmt.Println("s1:", s1)

}

输出：

1
2
3
4


a1: [1 2 -1 -2]
a2: [0 2 3 4]
a3: [1 2 3 4]
s1: [2 -1 -2]

Slice 保存的是长度、容量以及其底层数组的地址。

这里 s1 来自 a1 的切片，底层数组与 a1 同内存区域，所以对 s1 的 append 导致 a1 的数值被修改。

在使用中也要注意这种情况，合理使用。

使用三个索引创建切片

这种格式为：slice[i:j:k]的切片方式，前两个索引与原来相同，第三索引用于表示新切片的容量。但它不是直接表示容量大小，而是表示原切片或者数组的索引位置。当它越界时会出现运行时错误。

所以新切片的长度和容量应该这样计算：

1
2


长度：j - i
容量：k - i

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


func main() {
a1 := [4]int{1, 2, 3, 4}
// s1 来自 a1
s1 := a1[1:2:3]

 // 修改a[1]
 a1[1] = 0

 fmt.Println("a1:", a1)
 fmt.Println("s1:", s1)

 fmt.Println("-------------")

 // append s1
 s1 = append(s1, -1)
 s1 = append(s1, -2)

 fmt.Println("a1:", a1)
 fmt.Println("s1:", s1)

}

输出：

1
2
3
4
5
6
7


a1: [1 0 3 4]
s1: [0] // <-对`a[1]`的修改也影响了 s1

---

a1: [1 0 -1 4]
s1: [0 -1 -2]

使用slice[i:j:k]创建切片的时候，同样没有立即创建新的底层数组，只会在append导致len > cap扩容时才创建新数组。

Python 为图片添加文字水印

Thu, 10 May 2018 10:54:06 +0800

功能

使用知名python图片处理库PIL，为图片添加文字水印。

步骤：根据文字生成水印图片；将水印图半透明并覆盖在原图上。

实现

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


def gen_mark(args):
 # 字体宽度
 length = len(args.mark) * args.size

 # 创建水印图片(宽度、高度)
 mark = Image.new(mode='RGBA', size=(length, args.size))

 # 生成文字
 draw = ImageDraw.Draw(im=mark)
 draw.text(xy=(0, 0),
 text=args.mark, # 水印文字
 fill=args.color, # 文字颜色 '#008B8B'
 font=ImageFont.truetype(TTF_FONT, # 文字字体
 size=args.size)) # font_size 文字大小
 del draw

 # 裁剪图片边缘空白区域
 bg = Image.new(mode='RGBA', size=mark.size)
 diff = ImageChops.difference(mark, bg)
 del bg
 bbox = diff.getbbox()
 if bbox:
 mark = mark.crop(bbox)

 # 设置水印透明度
 set_opacity(mark, args.opacity)

 # 得到水印文字大小
 print(mark.size)
 此处省略...

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


def mark_im(im):
 ''' 在im图片上添加水印 im为打开的原图'''

 # 计算斜边长度
 c = int(math.sqrt(im.size[0]*im.size[0] + im.size[1]*im.size[1]))

 # 以斜边长度为宽高创建大图（旋转后大图才足以覆盖原图）
 mark2 = Image.new(mode='RGBA', size=(c, c))

 # 在大图上生成水印文字，此处mark为上面生成的水印图片
 y, idx = 0, 0
 while y < c:
 # 制造x坐标错位
 x = -int((mark.size[0] + args.space)*0.5*idx)
 idx = (idx + 1) % 2

 while x < c:
 # 在该位置粘贴mark水印图片
 mark2.paste(mark, (x, y))
 x = x + mark.size[0] + args.space
 y = y + mark.size[1] + args.space

 # 将大图旋转一定角度
 mark2 = mark2.rotate(args.angle)

 # 在原图上添加大图水印
 if im.mode != 'RGBA':
 im = im.convert('RGBA')
 im.paste(mark2, # 大图
 (int((im.size[0]-c)/2), int((im.size[1]-c)/2)), # 坐标
 mask=mark2.split()[3])
 del mark2
 return im

代码

github: 2Dou/watermarker

LeetCode 29. Divide Two Integers

Fri, 30 Mar 2018 16:59:00 +0800

Divide Two Integers

Description

Divide two integers without using multiplication, division and mod operator.

If it is overflow, return MAX_INT.

不使用乘法、除法、取余实现两个整数相除。

根据除法的原理，基本思路是使用减法获得结果。将被除数变为被减数，除数变为减数。被减数循环减去减数直到被减数比减数小，中间减去的个数即为除法结果。

考虑被除数比除数大很多的情况，为了提升效率，被减数需要指数增加。

Solution

 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


func abs(n int) int {
 if n < 0 {
 return -n
 }
 return n
}

func divide(dividend int, divisor int) int {
 if divisor == 0 {
 // 被除数为0!?
 return 0
 } else if divisor == 1 {
 return dividend
 } else if divisor == -1 {
 // 边界检查
 if dividend == math.MinInt32 {
 return math.MaxInt32
 }

 return -dividend
 }

 r, n := 0, 1
 a, b := abs(dividend), abs(divisor)

 if a < b {
 return 0
 }

 // 指数逼近
 for a >= b {
 a = a - b // 减去n个b
 r += n // 结果加上n

 b = b << 1 // 移位替代乘法
 n = n << 1
 }

 // 判断结果是否为负数
 if (dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0) {
 r = -r
 }

 // 余数大于被除数，继续相除
 if a >= abs(divisor) {
 if r < 0 {
 return r + divide(a, -abs(divisor))
 } else {
 return r + divide(a, abs(divisor))
 }
 }

 return r
}

Python 实现微信跳一跳外挂

Mon, 08 Jan 2018 10:00:41 +0800

使用 Python + adb 实现微信跳一跳外挂

源码地址

使用方法

安卓手机打开USB调试
打开USB调试方法，进入设置，找到开发者选项，打开并勾选USB调试；
如果没有开发者选项，进入关于手机，连续点击版本号7次，即可开启开发者选项
进入微信跳一跳并点开始游戏，运行python helper.py

实现原理

使用adb命令截图保存到本地

1
2
3
4
5


adb shell screencap -p | perl -pe 's/\\x0D\\x0A/\\x0A/g' > screen.png

# 如果没有 perl 可以先保存再pull
adb shell screencap -p /sdcard/screen.png
adb pull /sdcard/screen.png .

使用python解析图片并查找棋子和落点
- 根据棋子颜色，取底部左右两边特征点，以中点为棋子位置
- 寻找落点
  - 有小圆点，直接通过圆点颜色RGB(245, 245, 245)找出圆点位置作为落点
  - 纯色平台
    1. 从上往下查找第一个与背景色不同的点，作为平台顶点
    2. 从顶点开始向左下搜索与顶点相同颜色的点，找到平台左顶点
    3. 从顶点开始向右下搜索与顶点相同颜色的点，找到平台右顶点
    4. 以左右点中点为落点
  - 其他情况
    1. 同样从上往下查找第一个与背景色不同的点，作为平台顶点
    2. 通过固定斜率0.58、棋子当前位置，计算落点（图中红线交点）
使用adb命令模拟触摸

1

adb shell input swipe x y x y time #其中x和y是屏幕坐标，time是触摸时间，单位ms

详解

寻找棋子

直接通过棋子特征颜色查找其“最左点”和“最右点”，计算中点

 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


def find_cur_pos(img):
 '''
 查找棋子当前位置
 通过棋子底部颜色范围，搜索棋子左右点，以中点作为棋子当前位置
 '''
 width, height = img.width, img.height

 local = [(width, 0), (0, 0)]
 def put_in(x, y):
 left, right = local[0], local[1]
 if x < left[0]:
 left = (x, y)
 local[0] = left
 if x >= right[0]:
 right = (x, y)
 local[1] = right

 for x in range(int(width * 0.1), int(width * 0.9)):
 for y in range(int(height * 0.52), int(height * 0.62)):
 pixel = img.getpixel((x, y))
 r, g, b = pixel[0], pixel[1], pixel[2]
 if r < 45 and r > 40 and \
 g < 45 and g > 40 and \
 b < 75 and b > 70:
 put_in(x, y)

 if r < 60 and r > 50 and \
 g < 60 and g > 50 and \
 b < 90 and b > 80:
 put_in(x, y)

 left, right = local[0], local[1]
 if left[0] == width:
 return None

 x = int((left[0] + right[0]) / 2)
 y = int((left[1] + right[1]) / 2)
 return (x, y)

寻找小圆点

通过圆点颜色RGB(245, 245, 245)寻找落点

以落点在左边为例：

通过圆点颜色RGB(245, 245, 245)、斜率K、坐标x，计算斜线上的点并判断颜色

通常先查找到A点，然后分别向右和向下查找B和C点，以BC线段中点作为落点。

落点在右边时先搜索到的点A位置稍有不同，但算法相同

查找点A的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 查找点A
for x in ite:
 '''
 通过斜率计算斜线上的位置，并判断是否和圆点颜色一样
 '''
 y = int(cur[1] - 0.58 * abs(cur[0] - x))
 pixel = img.getpixel((x, y))
 r, g, b = pixel[0], pixel[1], pixel[2]
 if r == 245 and g == 245 and b == 245:
 one_of_circle = (x, y)
 break

寻找平台中心点

首先寻找平台顶点，然后寻找左右顶点，计算平台中心点

寻找平台顶点

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


next_top, top_pixel = None, None # 顶点坐标和颜色

# 从上往下查找第一个与背景色不同的点，作为平台顶点
for y in range(int(height * 0.3), int(height * 0.52)):
 # 背景色，因为有渐变，所以每行重新获取背景色
 bg_pixel = img.getpixel((width - 1, y))

 for x in ite:
 pixel = img.getpixel((x, y))

 # 渐变问题，允许差值
 if abs(pixel[0] - bg_pixel[0]) > 8 \
 or abs(pixel[1] - bg_pixel[1]) > 8 \
 or abs(pixel[2] - bg_pixel[2]) > 8:
 next_top = (x, y)
 top_pixel = pixel
 break
 if next_top != None:
 break

搜索左右顶点

这种方法在某些情形会出现错误，暂未处理。可以通过设定点与点之间的规则排除这些平台（距离、y差值范围等规则）

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


x, y = next_top
while True:
 while True:
 # 向左查找相同颜色点
 if not same_color(img.getpixel((x - 1, y)), top_pixel):
 break
 x -= 1

 # 向下一个像素
 if not same_color(img.getpixel((x, y + 1)), top_pixel):
 break
 y += 1
if x != next_top[0] and y != next_top[1]:
 left = (x, y)

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


x, y = next_top
while True:
 while True:
 # 向右查找相同颜色点
 if not same_color(img.getpixel((x + 1, y)), top_pixel):
 break
 x += 1

 # 向下查找相同颜色点
 if not same_color(img.getpixel((x, y + 1)), top_pixel):
 break
 y += 1
if x != next_top[0] and y != next_top[1]:
 right = (x, y)

其他情况计算落点

如果当前棋子位置有偏差，这种方式结果会出现偏差

1
2
3


# x, y 为平台顶点坐标
k = 0.58 # 斜率
y = cur[1] - k * float(x - cur[0])

模拟触摸

通过当前位置和落点位置计算出距离distance，然后触摸时长T = distance * P

不同分辨率下，系数P不同，需要查找

1600x2560机型推荐0.92

1440x2560机型推荐1.039

1080x1920机型推荐1.392

720x1280机型推荐2.078

参考

思路来自WechatJumpHelper

LeetCode 25. Reverse Nodes in k-Group

Fri, 29 Dec 2017 14:23:13 +0800

Reverse Nodes in k-Group

Description

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,

Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

将链表按长度k分组并反转

Solution

 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


func reverseKGroup(head *ListNode, k int) *ListNode {
 if head == nil || k <= 1 {
 return head
 }

 var newHead, lastGroupTail *ListNode

 nextGroupHead := head

 for nextGroupHead != nil {
 right := nextGroupHead

 // search the first node of reversed-group
 for n := 0; n < k-1 && right != nil; n++ {
 right = right.Next
 }

 if right == nil {
 // no more group, so break
 break
 }

 if newHead == nil {
 // first group, set newHead
 newHead = right
 } else {
 // else, link last group and this group
 lastGroupTail.Next = right
 }

 // saving infomation to search next group
 lastGroupTail, nextGroupHead = nextGroupHead, right.Next

 // reversing this group
 left, right := lastGroupTail, nextGroupHead
 for left != nextGroupHead {
 left, left.Next, right = left.Next, right, left
 }
 }

 if newHead == nil {
 return head
 }

 return newHead
}

LeetCode 23. Merge K Sorted Lists

Fri, 24 Nov 2017 14:55:46 +0800

Merge k Sorted Lists

Description

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

将k个有序链表合并为一个链表

Solution

前面刚做了两条链表的合并Merge Two Sorted Lists。

既然两个的合并都做了，k个还会难吗？

显然，将k个链表两两合一即可。

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


func mergeKLists(lists []*ListNode) *ListNode {
 if len(lists) == 0 {
 return nil
 }

 res := lists[0]

 for i := 1; i < len(lists); i++ {
 res = mergeTwoLists(res, lists[i])
 }

 return res
}

LeetCode 22. Generate Parentheses

Wed, 22 Nov 2017 11:32:00 +0800

Generate Parentheses

Description

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

1
2
3
4
5
6
7


[
 "((()))",
 "(()())",
 "(())()",
 "()(())",
 "()()()"
]

给出n组括号，生成所有正确的匹配组合

Solution

本题不贴代码。

思路是生成过程中，保持右括号数量不超过左括号数量即可。

LeetCode 21. Merge Two Sorted Lists

Wed, 22 Nov 2017 09:15:44 +0800

Merge Two Sorted Lists

Description

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

将两个有序链表合二为一

Solution

逐次比较l1、l2，将较小的那个结点添加到新链表尾部，并指向下一个结点

 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


/**
 * Definition for singly-linked list.
 * type ListNode struct {
 * Val int
 * Next *ListNode
 * }
 */
func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
 if l1 == nil {
 return l2
 } else if l2 == nil {
 return l1
 }

 var head, tail *ListNode

 // 将首次判断放在循环外，可以减少判断次数，提高效率
 if l1.Val < l2.Val {
 head = l1
 l1 = l1.Next
 } else {
 head = l2
 l2 = l2.Next
 }

 tail = head

 for {
 if l1 == nil {
 tail.Next = l2
 break
 } else if l2 == nil {
 tail.Next = l1
 break
 } else if l1.Val < l2.Val {
 tail.Next = l1
 tail = l1
 l1 = l1.Next
 } else {
 tail.Next = l2
 tail = l2
 l2 = l2.Next
 }
 }

 return head
}

LeetCode 20. Valid Parentheses

Mon, 30 Oct 2017 19:25:35 +0800

Valid Parentheses

Description

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

给出包含三种括号的字符串，验证括号是否左右匹配

Solution

 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


func isValid(s string) bool {
 var c byte
 stack := make([]byte, 0)
 m := map[byte]byte{
 ')': '(',
 ']': '[',
 '}': '{',
 }
 for i := 0; i < len(s); i++ {
 c = s[i]
 if c == '(' || c == '[' || c == '{' {
 stack = append(stack, c)
 } else {
 if v, ok := m[c]; ok {
 if !pop(v, &stack) {
 return false
 }
 } else {
 return false
 }
 }
 }

 return len(stack) == 0
}

func pop(c byte, stack *[]byte) bool {
 l := len(*stack)
 if l < 1 {
 return false
 }

 var poped byte
 *stack, poped = (*stack)[:l-1], (*stack)[l-1]

 return poped == c
}

LeetCode 19. Remove Nth Node From End of List

Thu, 19 Oct 2017 21:03:59 +0800

Remove Nth Node From End of List

Description

Given a linked list, remove the nth node from the end of list and return its head.
1
2
3
For example,
 Given linked list: 1->2->3->4->5, and n = 2.
 After removing the second node from the end, the linked list becomes 1->2->3->5.
Note:
Given n will always be valid.
Try to do this in one pass.

从链表中删除倒数第n个结点（n必定有效）

Solution

1. 使用循环

定义 p1 = p2 = head
先让p1前进n个结点。如果此时n为空，说明要删除的是head结点，直接返回head.Next，否则进行后面步骤
此时p1与p2相差n个结点。让p1、p2同时前进，知道p1指向尾结点，此时p2指向倒数第n+1个结点
删除p2.Next(即倒数第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


/**
 * Definition for singly-linked list.
 * type ListNode struct {
 * Val int
 * Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
 p1 := head

 // point the next Nth node
 for i := 0; i < n; i++ {
 p1 = p1.Next
 }

 if p1 == nil {
 // It's removing the first node from begin
 return head.Next
 }

 p2 := head // p2 is now n step behind p1

 // let p1 point to the 1st node from end
 // so p2 is pointing to the (n+1)th node from end
 for p1.Next != nil {
 p1 = p1.Next
 p2 = p2.Next
 }

 // now remove the Nth node from begin
 p2.Next = p2.Next.Next

 return head
}

2. 使用递归

使用递归一直向后查找，直到最后一个结点(head.Next == nil)。此时递归结束，开始返回：当前结点指针和0。相当于将最后一个结点标记为0
判断递归返回的标记是否等于n，是则表示p为倒是第(n+1)个结点（因为标记从0开始），也是我们需要查找的结点。否则将标记加1，返回head（即p的父节点）。
递归完全返回后，函数removeNthFromEnd里的 index 如果为0，则表示parent指向第倒数n+1；不为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


/**
 * Definition for singly-linked list.
 * type ListNode struct {
 * Val int
 * Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
 parent, index := search(head, n)
 if index != n {
 // It must be removing the first node from begin
 return head.Next
 }

 // remove the child node
 parent.Next = parent.Next.Next

 return head
}

func search(head *ListNode, n int) (*ListNode, int) {
 if head.Next == nil {
 // mark last node's index as 0
 return head, 0
 }

 p, index := search(head.Next, n)
 if index == n {
 // so index n is the (n+1)th node from the end
 // it's the parent of the node which we want to remove
 return p, index
 }

 return head, index + 1
}

树莓派 Raspbian系统安装与基本配置

Wed, 18 Oct 2017 16:44:36 +0800

系统安装

系统: raspbian

工具（二选一）：

Etcher
Win32DiskImager（windows only）

将SD卡格式化成exFat格式
使用Etcher或者Win32DiskImager将下载的raspbian系统镜像(img文件)写入SD卡

写入完成之后就相当于系统安装完成了。这时候SD卡被分成两个区，有一个区是在windows下无法识别，不用理会。

这时候如果直接将SD卡插入树莓派，会发现“无法启动”。显示屏没信号，在路由器里找到树莓派的IP也无法用ssh登录。

我安装的时候就是踩到这个坑。以为安装失败，反复装了好几次，就差把SD卡写穿了。

实际系统安装已经成功了。只需要在电脑上打开SD卡，找到config.txt文件里#hdmi_safe=1这一行，将前面的#号去掉；
再新建一个文件命名为ssh（不能有扩展名）。

再次把SD卡装进树莓派启动，显示屏就可以正常显示了，ssh也能登录了。

基本配置

1. 静态IP/固定IP

打开/etc/dhcpcd.conf文件，找到网口（一般为eth0）

指定IP:

1
2
3


interface eth0
static ip_address=192.168.1.20/24
static routers=192.168.1.1

2. iptables

刚开始配置iptables的时候，以为创建好规则后，使用iptables-save就可以保存了，结果重启后又失效。

为了持久化规则，可以使用iptables-persistent。

运行apt-get安装：sudo apt-get install iptables-persistent安装。

然后在/etc/iptables/rules.v4里面编辑规则

3. 修改主机名

需要修改两个文件：

替换/etc/hostname里的主机名
替换/etc/hosts里的主机名

4. 修改用户名

为了修改默认用户名pi，需要临时使用root帐号登录。

启用root帐号
1 2 3 4

# 为root帐号设置密码 sudo passwd root # 启用root帐号 sudo passwd --unlock root
ssh默认是禁止root登录的，所以还需要修改ssh配置：编辑文件/etc/ssh/sshd_config，添加一行PermitRootLogin yes即可。
1 2

# 重启 sudo reboot

重启系统并登录root后修改pi账户

1
2
3
4
5
6
7
8


# 修改用户名为NEWNAME
usermod -l NEWNAME pi
# 修改用户group
groupmod -n NEWNAME pi
# 修改账户主目录
mv /home/pi /home/NEWNAME
# 设置主目录
usermod -d /home/NEWNAME NEWNAME

重启登录NEWNAME

登录后检查新用户是否能正常使用sudo，如果不能则再次使用root登录，往/etc/sudoers中添加一行：NEWNAME ALL=(ALL) ALL。
新账户正常后禁用root
1 2

# 禁用root sudo passwd -l root
别忘了还有ssh配置文件也要修改。

LeetCode 18. 4Sum

Tue, 17 Oct 2017 16:27:33 +0800

4Sum

Description

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note: The solution set must not contain duplicate quadruplets.
1
2
3
4
5
6
7
8
For example, given array S = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
 [-1, 0, 0, 1],
 [-2, -1, 1, 2],
 [-2, 0, 0, 2]
]

在给定数组中找出“和为 target 的四个数”的所有解。

需要避免重复的解。

这次的答案适用N个数的和；好理解。

Solution

 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


func fourSum(nums []int, target int) [][]int {
 sort.Ints(nums)
 return sum(nums, target, 4)
}

func sum(nums []int, target int, n int) [][]int {
 if len(nums) < n || // not enough numbers
 sumOfSlice(nums[len(nums)-n:]) < target || // max-sum still smaller than target
 sumOfSlice(nums[:n]) > target { // min-sum still bigger than target

 // no answer
 return [][]int{}
 }

 res := make([][]int, 0)
 for i := 0; i < len(nums); i++{
 num := nums[i]
 if n == 1 && num == target {
 return [][]int{
 []int{num},
 }
 } else if n > 1 {
 // let's suppose num is one of the n numbers
 // so the other n-1 numbers' sum is target-num
 // then search the rest numbers
 for _, r := range sum(nums[i+1:], target-num, n-1) {
 res = append(res, append(r, num))
 }

 // skip the same numbers
 for j := i + 1; j < len(nums) && nums[j] == num; j++ {
 i++
 }
 }
 }

 return res
}

// get sum of slice
func sumOfSlice(nums []int) int {
 if len(nums) == 1 {
 return nums[0]
 }

 return nums[0] + sumOfSlice(nums[1:])
}

LeetCode 17. Letter Combinations of a Phone Number

Tue, 17 Oct 2017 14:39:40 +0800

Letter Combinations of a Phone Number

Description

Given a digit string, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.

1
2


Input: Digit string "23"
Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

输入九宫格输入法数字，输出对应的所有字母组合

Solution

 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


func letterCombinations(digits string) []string {
 if len(digits) < 1 {
 return []string{}
 }

 if len(digits) == 1 {
 switch digits {
 case "2":
 return []string{"a", "b", "c"}
 case "3":
 return []string{"d", "e", "f"}
 case "4":
 return []string{"g", "h", "i"}
 case "5":
 return []string{"j", "k", "l"}
 case "6":
 return []string{"m", "n", "o"}
 case "7":
 return []string{"q", "p", "r", "s"}
 case "8":
 return []string{"t", "u", "v"}
 case "9":
 return []string{"w", "x", "y", "z"}
 case "0":
 return []string{" "}
 default:
 return []string{""}
 }
 }

 r := make([]string, 0)

 for _, front := range letterCombinations(digits[:1]) {
 for _, back := range letterCombinations(digits[1:]) {
 r = append(r, front+back)
 }
 }

 return r
}

自动点击 - 申请Google Voice号码

Wed, 09 Aug 2017 08:44:10 +0800

最近V2上很多卖GV号码的，心想这玩意也能值钱。所以想着自己试试动手申请一个。

首先参照这篇

“免费申请Google Voice美国电话号码”申请号码。

到了这一步：提示“There was an error with your request. Please try again.”

听说在这里反复提交直到申请成功即可。找了网上的自动提交方法（复制出来CURL提交），发现不好使，curl一直没响应。
但是网页上确实可以反复点击提交的。于是改用自动点击的方式，一夜醒来发现已经申请成功。

使用Chrome浏览器，右键->审查元素。

然后切换到Console中粘贴以下代码，回车，实现自动点击。

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


function triggerMouseEvent (node, eventType) {
 var clickEvent = document.createEvent ('MouseEvents');
 clickEvent.initEvent (eventType, true, true);
 node.dispatchEvent (clickEvent);
}

function clickTheBtn(){
 // 查找按钮
 var btn = document.getElementsByClassName("continueButton")[0];

 // 模拟点击
 triggerMouseEvent(btn, "mouseover");
 triggerMouseEvent(btn, "mousedown");
 triggerMouseEvent(btn, "mouseup");
 triggerMouseEvent(btn, "click");
}

// 每2.5秒调用一次clickTheBtn
setInterval(clickTheBtn, 2500);

LeetCode 15. 3Sum

Fri, 28 Jul 2017 08:54:12 +0800

3Sum

Description

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note: The solution set must not contain duplicate triplets.
1
2
3
4
5
6
7
For example, given array S = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
 [-1, 0, 1],
 [-1, -1, 2]
]

在给定数组中找出“和为0的三个数”的所有解。

需要避免重复的解（相同数字组合的解为重复）。

Solution

 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


func threeSum(nums []int) (res [][]int) {
 if len(nums) < 3 {
 return
 }

 // 从小到大排序
 sort.Ints(nums)

 for i := 0; i < len(nums)-2; i++ {
 left, right := i+1, len(nums)-1
 num0 := nums[i]
 num1 := nums[left]
 num2 := nums[right]

 // 所有数同符号则不需要继续
 if (num0 > 0 && num1 > 0) ||
 (num0 < 0 && num2 < 0) {
 break
 }

 for left < right {
 // 求和
 sum := num0 + num1 + num2

 if sum == 0 {
 // 记录满足条件的解
 res = append(res, []int{num0, num1, num2})

 // 跳过相同的数字避免重复解
 for left < right && num1 == nums[left] {
 left++
 }

 for right < left && num2 == nums[right] {
 right--
 }
 } else if sum < 0 {
 // 和为负数则增加num1
 left++
 } else {
 // 和为正数则减小num2
 right--
 }

 num1 = nums[left]
 num2 = nums[right]
 }

 // 跳过相同的num0避免重复解
 for i < len(nums)-2 && num0 == nums[i+1] {
 i++
 }
 }

 return res
}

LeetCode 13. Roman to Integer

Fri, 07 Jul 2017 14:43:41 +0800

Roman to Integer

Description

Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

将罗马数字转换成整型。

Solution

 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


func romanToInt(s string) int {
 num := map[uint8]int{
 'M': 1000,
 'D': 500,
 'C': 100,
 'L': 50,
 'X': 10,
 'V': 5,
 'I': 1,
 }

 length := len(s)

 if length == 0 {
 return 0
 }

 res := num[s[length-1]]
 for i := length - 2; i >= 0; i-- {
 n := num[s[i]]

 if n < num[s[i+1]] {
 res -= n
 } else {
 res += n
 }
 }

 return res
}

LeetCode 12. Integer to Roman

Fri, 07 Jul 2017 09:18:49 +0800

Integer to Roman

Description

Given an integer, convert it to a roman numeral.

Input is guaranteed to be within the range from 1 to 3999.

将整型转换成罗马数字形式:

Symbol	Value
I	1
V	5
X	10
L	50
C	100
D	500
M	1000

Solution

因为限定了范围，所以千位数也用了Slice

1
2
3
4
5
6
7
8


func intToRoman(num int) string {
 M := []string{"", "M", "MM", "MMM"}
 C := []string{"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"}
 X := []string{"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"}
 I := []string{"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"}

 return M[num/1000] + C[(num%1000)/100] + X[(num%100)/10] + I[num%10]
}

LeetCode 11. Container With Most Water

Thu, 06 Jul 2017 14:09:43 +0800

Container With Most Water

Description

Given n non-negative integers a1, a2, …, an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

Note: You may not slant the container and n is at least 2.

给出n个点，它们与X轴有n条垂线，每两条垂线与X轴形成的U型容器，找出最大“容积”(面积）

Solution

从两边往中间逼近。每次循环收紧矮的一边。

 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


func maxArea(height []int) int {
 area := 0
 left, right := 0, len(height)-1

 for left < right {
 width := right - left
 h := 0

 if height[right] > height[left] {
 h = height[left]
 left++
 } else {
 h = height[right]
 right--
 }

 a := width * h
 if a > area {
 area = a
 }
 }

 return area
}

func min(a, b int) int {
 if a > b {
 return b
 }

 return a
}

天龙八部

Wed, 31 May 2017 17:54:35 +0800

LeetCode 51. N-Queens

Thu, 04 May 2017 16:23:01 +0800

N-Queens

Description

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens’ placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

For example,
There exist two distinct solutions to the 4-queens puzzle:

[
[".Q..", // Solution 1
“…Q”,
“Q…”,
“..Q.”],

["..Q.", // Solution 2
“Q…”,
“…Q”,
“.Q..”]
]

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



这是我第一次做八皇后问题，之前只是听说这么一个名字。

思路与之前[Sudoku-Solver](http://www.orztu.com/leetcode/Sudoku-Solver/)相同，
使用递归遍历每一行所有位置，判断该位置是否合法，不合法返回，合法则进入下一行。

好像大家给这种方法取了一个很洋气的名字叫*回溯*

<small>*在国际象棋中，皇后可以攻击直线和斜线上的目标*</samll>


## Solution



 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


func solveNQueens(n int) [][]string {
 answer := make([][]string, 0)

 board := make([]int, n)
 solve(&answer, board, n, 0)

 return answer
}

// put a queen on board at line l
func solve(answer *[][]string, board []int, n, l int) {
 if n == l {
 *answer = append(*answer, convertBoard(board, n))
 return
 }

 for i := 0; i < n; i++ {
 if !canBeAttack(board, n, l, i) {
 // mark the queen's postion
 board[l] = i
 solve(answer, board, n, l+1)
 }
 }
}

// 判断会否被其他皇后攻击
func canBeAttack(board []int, n, x, y int) bool {
 for row := 0; row < x; row++ {
 col := board[row]
 if col == y || abs(row-x) == abs(col-y) {
 return true
 }
 }

 return false
}

// 转换成返回格式
func convertBoard(board []int, n int) []string {
 ans := make([]string, n)
 for i := 0; i < n; i++ {
 line := []byte(strings.Repeat(".", n))
 line[board[i]] = 'Q'
 ans[i] = string(line)
 }

 return ans
}

func abs(x int) int {
 if x < 0 {
 return -x
 }

 return x
}

LeetCode 42. Trapping Rain Water

Fri, 28 Apr 2017 10:01:32 +0800

Trapping Rain Water

Description

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how >much water it is able to trap after raining.

For example,
Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Solution

每个点容量决定于左右两边高度

先从左往右，扫描出每个点左边最高的围栏

再从右往左，扫描出每个点右边最高的围栏

在围栏比当前点高的情况下，这个点的容量为围栏高度减底部高度: min(left_height, right_height) - bottom

 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


func trap(height []int) int {
 var record int
 var result int

 length := len(height)

 if length < 3 {
 return 0
 }

 leftHeight := make([]int, length)

 record = height[0] // record the max height of left positions
 // scan left height for each position
 for i := 0; i < length-1; i++ {
 leftHeight[i] = record

 n := height[i]
 if n > record {
 record = n
 }
 }

 record = height[length-1] // record the max height of right positions
 for i := length - 2; i >= 0; i-- {
 h := min(record, leftHeight[i])
 n := height[i]

 if h > n {
 // have some water
 result += (h - n)
 }

 if n > record {
 record = n
 }
 }

 return result
}

func min(a, b int) int {
 if a < b {
 return a
 }
 return b
}

LeetCode 37. Sudoku Solver

Sat, 22 Apr 2017 11:35:12 +0800

Sudoku Solver

Description

Write a program to solve a Sudoku puzzle by filling the empty cells.

Empty cells are indicated by the character ‘.’.

You may assume that there will be only one unique solution.

Solution

还是编程思维不行，在编程时按照解题思路在走。

我的答案：
查找空格，找出该位置可能的数字组合，填入，递归进入下一个空格。
这样虽然能解出答案。但是在查找可能的数字上耗费时间较多。

后面的Pretty Solution：
找到空格后，直接把依次把1-9填入，验证是否重复。反而耗时更少，代码也更简洁。

My solution

 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


func solveSudoku(board [][]byte) {
 setNumber(&board, 0)
}

func setNumber(board *[][]byte, index int) bool {
 row := int(index / 9)
 col := index % 9

 if index >= 81 {
 return true
 }

 canbe := getPossibleNumbers(*board, row, col)
 if len(canbe) == 0 {
 return false
 }

 reset := (*board)[row][col]
 ok := true
 for _, num := range canbe {
 (*board)[row][col] = num
 ok = setNumber(board, index + 1)
 if ok {
 break
 }
 }

 if !ok {
 (*board)[row][col] = reset
 }

 return ok
}

func getPossibleNumbers(board [][]byte, i, j int) []byte {
 num := board[i][j]
 if num != '.' {
 // skip this position
 return []byte{num}
 }

 canbe := map[byte]struct{}{
 '1': struct{}{},
 '2': struct{}{},
 '3': struct{}{},
 '4': struct{}{},
 '5': struct{}{},
 '6': struct{}{},
 '7': struct{}{},
 '8': struct{}{},
 '9': struct{}{},
 }

 // check row-i, remove number from 'canbe' which have been set to other postion
 for col := 0; col < 9; col++ {
 if col == j {
 continue
 }

 if removeFromPossibleNumber(&canbe, board[i][col]) == 0 {
 return []byte{}
 }
 }

 // check col-j, remove number from 'canbe' which have been set to other postion
 for row := 0; row < 9; row++ {
 if row == i {
 continue
 }
 if removeFromPossibleNumber(&canbe, board[row][j]) == 0 {
 return []byte{}
 }
 }

 // check the little sudoku block
 left := 3 * int(i / 3)
 top := 3 * int(j / 3)
 for l := 0; l < 3; l++ {
 for t := 0; t < 3; t++ {
 index_i := left + l
 index_j := top + t

 if index_i == i && index_j == j {
 continue
 }

 if removeFromPossibleNumber(&canbe, board[index_i][index_j]) == 0 {
 return []byte{}
 }
 }
 }

 var n byte
 var result []byte
 for n = '1'; n <= '9'; n++ {
 if _, ok := canbe[n]; ok {
 result = append(result, n)
 }
 }

 return result
}

func removeFromPossibleNumber(canbe *map[byte]struct{}, key byte) int {
 if _, ok := (*canbe)[key]; ok {
 delete(*canbe, key)
 }

 return len(*canbe)
}

Pretty solution

 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


func solveSudoku(board [][]byte) {
 setNumber(&board, 0)
}

func setNumber(board *[][]byte, index int) bool {
 row := int(index / 9)
 col := index % 9

 if index >= 81 {
 return true
 }

 if (*board)[row][col] == '.' {
 var c byte
 for c = '1'; c <= '9'; c++ {
 (*board)[row][col] = c
 if valid(board, row, col) && setNumber(board, index + 1) {
 return true
 }
 (*board)[row][col] = '.'
 }
 return false
 } else {
 return setNumber(board, index + 1)
 }
}

func valid(board *[][]byte, row, col int) bool {
 num := (*board)[row][col]

 // check row
 for i := 0; i < 9; i++ {
 if i == row {
 continue
 }
 if (*board)[i][col] == num {
 return false
 }
 }

 // check col
 for j := 0; j < 9; j++ {
 if j == col {
 continue
 }
 if (*board)[row][j] == num {
 return false
 }
 }

 // check the little sudoku block
 left := 3 * int(row / 3)
 top := 3 * int(col / 3)
 for i := left; i < left + 3; i++ {
 for j := top; j < top + 3; j++ {
 if i == row && j == col {
 continue
 }

 if (*board)[i][j] == num {
 return false
 }
 }
 }

 return true
}

LeetCode 10. Regular Expression Matching

Fri, 24 Mar 2017 15:00:47 +0800

Regular Expression Matching

Description

Implement regular expression matching with support for ‘.’ and ‘*’.

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


'.' Matches any single character.
'*' Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "a*") → true
isMatch("aa", ".*") → true
isMatch("ab", ".*") → true
isMatch("aab", "c*a*b") → true

简单的字符匹配

Solution

 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


func isMatch(s string, p string) bool {
 if len(s) == 0 && len(p) == 0 {
 return true
 } else if len(p) == 0 {
 // p is empty but s
 return false
 }

 matchChar := p[0]

 if len(p) > 1 && p[1] == '*' {
 // match any numbers of char(s)

 // eat two char of p
 p = p[2:]

 for len(s) > 0{
 if s[0] == matchChar || matchChar == '.' {
 // try not to eat char of s
 if isMatch(s, p) {
 return true
 }

 // let's eat one char of s and try again
 s = s[1:]
 } else {
 break
 }
 }
 } else {
 // match one char

 // eat one char of p
 p = p[1:]

 // does it match?
 if len(s) == 0 || (s[0] != matchChar && matchChar != '.') {
 return false
 }

 // eat one char of s
 s = s[1:]
 }

 return isMatch(s, p)
}

LeetCode 9. Palindrome Number

Fri, 24 Mar 2017 15:00:46 +0800

Palindrome Number

Description

Determine whether an integer is a palindrome. Do this without extra space.

在不使用额外空间的条件下判断一个整型是否为回文

我认为这是一个伪命题(wtf? without extra space?)

Solution

Pretty solution

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


func isPalindrome(x int) bool {
 if x < 0 || (x != 0 && x%10 == 0) {
 return false
 }

 sum := 0
 for x > sum {
 sum = sum * 10 + x % 10
 x = x / 10
 }
 return (x == sum) || (x == sum / 10)
}

My solution

 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


func isPalindrome(x int) bool {
 if x < 0 {
 return false
 }

 if x < 10 {
 return true
 }

 // get len(string(x)) - 1
 l := 0
 for i := x; i >= 10; i /= 10 {
 l++
 }

 mod := 1
 for i := 0; i < l; i++ {
 mod *= 10
 }

 lnum, rnum := x, x
 for i := 0; i < (l + 1) / 2; i++ {
 fmt.Println(lnum, rnum)

 l := lnum / mod
 r := rnum - (rnum / 10 * 10)

 lnum = lnum - (l * mod)
 mod /= 10

 rnum /= 10

 fmt.Println(l, r)
 if l != r {
 return false
 }
 }

 return true
}

LeetCode 8. String to Integer (atoi)

Wed, 22 Mar 2017 09:05:12 +0800

String to Integer (atoi)

Description

Implement atoi to convert a string to an integer.

Hint: Carefully consider all possible input cases. If you want a challenge, please do not see below and ask yourself what are the > possible input cases.

Notes: It is intended for this problem to be specified vaguely (ie, no given input specs). You are responsible to gather all the > input requirements up front.

实现atoi功能

需要注意边界检查

Solution

 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


func myAtoi(str string) int {
 str = strings.TrimLeft(str, " ")

 if len(str) == 0 {
 return 0
 }

 r := 0
 sign := 1

 if str[0] == '-' {
 sign = -1
 str = str[1:]
 } else if str[0] == '+' {
 str = str[1:]
 }

 for i := 0; i < len(str); i++ {
 c := str[i]
 if c >= '0' && c <= '9' {
 r = r * 10 + (int(c - '0') * sign)

 if r <= math.MinInt32 {
 return math.MinInt32
 } else if r >= math.MaxInt32 {
 return math.MaxInt32
 }
 } else {
 break
 }
 }

 return r
}

LeetCode 7. Reverse Integer

Tue, 21 Mar 2017 16:04:44 +0800

Reverse Integer

Description

Reverse digits of an integer.

Example1: x = 123, return 321

Example2: x = -123, return -321

The input is assumed to be a 32-bit signed integer. Your function should return 0 when the reversed integer overflows.

将输入的十进制数倒序输出

Solution

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


func reverse(x int) int {
 r := 0

 for x != 0 {
 r *= 10
 r += x % 10
 x /= 10
 }

 if -math.MaxInt32 < r && r < math.MaxInt32 {
 return r
 }

 return 0
}

LeetCode 6. ZigZag Conversion

Fri, 17 Mar 2017 17:52:46 +0800

ZigZag Conversion

Description

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this > pattern in a fixed font for better legibility)

1
2
3


P A H N
A P L S I I G
Y I R

And then read line by line: "PAHNAPLSIIGYIR"

Write the code that will take a string and make this conversion given a number of rows:

1

string convert(string text, int nRows);

convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".

输入之字字符串和之字的行数，要求按行输出字符串。

"A-Z"5行的之字字符:

1
2
3
4
5
6
7


 0 1 2 3 4 5 6 7 8 ...

0 A I Q Y
1 B H J P R X Z
2 C G K O S W
3 D F L N T V
4 E M U

可以看出：

第0、第4、第8、第12列每行都有字符，其他列只有一个字符 col % (5 - 1) == 0
其他列字符所在行: row = (5 - 1) - (col % (5 - 1))
字符在输入字符串中的位置(0起)等于: index = col * 2 + row

Solution

 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


func convert(s string, numRows int) string {
 /* 0 1 2 3 4 5 6 col
 * +----------------------
 * 0 | 0 x x 6 x x 12
 * 1 | 1 x 5 7 x 11
 * 2 | 2 4 x 8 10
 * 3 | 3 x x 9
 * row +----------------------
 *
 * col0: each line have a char
 * col1: the char is at row2
 * col2: the char is at row1
 * .
 * col4: the char is at row2
 *
 * the char is at row( 4 - (col % 3) ) except col0、col0+3、col0+3+3...
 */

 if numRows == 1 {
 return s
 }

 var res string

 for row := 0; row < numRows; row++ {
 for col := 0; ; col++ {
 m := col % (numRows - 1)

 // if m == 0 there must be a char
 // else numRows-m eq the char' row-index
 if m == 0 || row == (numRows - 1) - m{
 idx := (col << 1) + row

 if idx >= len(s) {
 break
 }

 res += string(s[idx])
 }
 }
 }

 return res
}

LeetCode 5. Longest Palindromic Substring

Thu, 16 Mar 2017 14:47:07 +0800

Longest Palindromic Substring

Description

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example:

1
2


Input: "babad"
Output: "bab"

Note: “aba” is also a valid answer.

Example:

1
2


Input: "cbbd"
Output: "bb"

从给定字符串中找出最长的回文子串

Solution

从最大长度开始判断是否回文，是则返回

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


func longestPalindrome(s string) string {
 maxLen := len(s)

 for l := maxLen; l > 0; l-- {
 for i := 0; i + l <= maxLen; i++ {
 lp, rp := i, i + l -1

 for lp < rp && s[lp] == s[rp] {
 lp++
 rp--
 }

 if lp >= rp {
 return s[i:i+l]
 }
 }
 }

 return s[0:1]
}

LeetCode 4. Median of Two Sorted Arrays

Thu, 16 Mar 2017 10:53:58 +0800

Median of Two Sorted Arrays

Description

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Example 1:

1
2


nums1 = [1, 3]
nums2 = [2]

The median is 2.0
Example 2:

1
2


nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

从两个有序数组中求中位数

Solution

通过数组长度，计算中位数的位置。在两个数组中按大小顺序依次查找，找到中位数所在位置，取出数值计算。

 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


func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
 totalLen := len(nums1) + len(nums2)

 var p1, p2, index1, index2, sum int

 index1 = int((totalLen - 1) / 2)
 index2 = int(totalLen / 2)

 for i := 0; i < totalLen; i++ {
 if i > index2 {
 break
 }
 var num int
 if p1 < len(nums1) && p2 < len(nums2) {
 if nums1[p1] < nums2[p2] {
 num = nums1[p1]
 p1++
 } else {
 num = nums2[p2]
 p2++
 }
 } else if p1 < len(nums1) {
 num = nums1[p1]
 p1++
 } else {
 num = nums2[p2]
 p2++
 }

 if i == index1 {
 sum += num
 }
 if i == index2 {
 sum += num
 }
 }

 return float64(sum) / 2.0
}

LeetCode 3. Longest Substring Without Repeating Characters

Wed, 15 Mar 2017 19:38:58 +0800

Longest Substring Without Repeating Characters

Description

Given a string, find the length of the longest substring without repeating characters.

Given “abcabcbb”, the answer is “abc”, which the length is 3.

Given “bbbbb”, the answer is “b”, with the length of 1.

Given “pwwkew”, the answer is “wke”, with the length of 3. Note that the answer must be a substring, “pwke” is a subsequence and not a substring.

在给定字符串中找出无重复字符的最长子串。

Solution

 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


func lengthOfLongestSubstring(s string) int {
 l := len(s)
 maxLen := 0

 for p1 := 0; p1 < l; p1++ {
 m := map[uint8]bool{}

 for p2 := p1; p2 < l; p2++{
 c := s[p2]

 _, ok := m[c]
 if ok {
 break
 } else {
 m[c] = true
 }
 }

 if len(m) > maxLen {
 maxLen = len(m)
 }
 }

 return maxLen
}

LeetCode 2. Add Two Numbers

Wed, 15 Mar 2017 16:55:54 +0800

Add Two Numbers

Description

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

1
2


Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

给定两个非空链表表示的非负整数。实现加法，向后进位。

Solution

用一个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


/**
 * Definition for singly-linked list.
 * type ListNode struct {
 * Val int
 * Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
 head := &ListNode{}
 cur := head
 carry := 0

 for {
 var v1, v2 int
 if l1 != nil {
 v1 = l1.Val
 l1 = l1.Next
 }

 if l2 != nil {
 v2 = l2.Val
 l2 = l2.Next
 }

 v := v1 + v2 + carry

 carry = int(v / 10)
 cur.Val = v % 10

 if l1 != nil || l2 != nil {
 cur.Next = &ListNode{}
 cur = cur.Next
 } else {
 if carry > 0 {
 cur.Next = &ListNode{Val: carry}
 }

 break
 }
 }

 return head
}

LeetCode 1. Two Sum

Wed, 15 Mar 2017 16:36:59 +0800

Two Sum

Description

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

1
2


Example:
Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

假定只有唯一解的情况下在数组中找出和为target的两个数

Solution

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


func twoSum(nums []int, target int) []int {
 res := make([]int, 2)
 m := map[int]int{}

 for i := range nums {
 m[target - nums[i]] = i
 }

 for i := range nums {
 idx, ok := m[nums[i]]
 if ok {
 if i == idx {
 continue
 }
 res[0] = idx
 res[1] = i
 sort.Ints(res)
 break
 }
 continue
 }

 return res
}

Hello World

Tue, 14 Mar 2017 00:00:00 +0000

国际惯例

About me

Sun, 01 Jan 2017 00:00:00 +0000

城市永远年轻，而我们终将老去

info

~~cocos2dx-lua 程序猿~~ 我可能是个假cocos2d-x
又变成 Unity 开发仔 + 半吊子 TA + 工具人了

contact

h3rvgo AT gmail.com

Links

Mon, 01 Jan 0001 00:00:00 +0000

Search

Mon, 01 Jan 0001 00:00:00 +0000