张磊的技术笔记

从零跑通 NeuG：导入数据，完成第一次图查询

Wed, 30 Sep 2026 00:00:00 GMT

修改一个公共函数之前，我们常常要先回答两个问题：谁在调用它？改动可能影响哪些上层模块？

调用点不多时，用编辑器跳转就能找到答案。调用链一长，就得逐层查看函数、记录路径，再整理涉及的文件。有了调用关系数据，这些工作可以交给图查询。

下面用 NeuG 存储一张代码依赖图：先定义模型、导入 CSV，再查找直接和间接调用者，最后列出它们所在的文件。

本文示例已在 NeuG 0.2.0、Python 3.11.9、macOS 15.1.1 / ARM64 上运行验证。数据为人工构造，不涉及真实项目。文档核对日期为 2026 年 9 月 30 日。

为什么用 NeuG 做这个例子

NeuG 支持图数据存储和 Cypher 查询，既可以嵌入应用进程，也可以通过服务访问。本篇使用 Python 嵌入式接口：在脚本中打开数据库、建立连接，直接执行查询，无需另外启动数据库服务。官方介绍

A 调用 B，可以表示为一条从 A 指向 B 的边。函数与源文件之间再加一条“定义于”关系，就能从调用链查到文件。

这组数据很小，用字典和遍历算法也能处理。用它入门的好处是，每条查询的结果都可以对着图核对。

先把调用关系画出来

假设项目中有三个文件，共八个函数。

文件	函数
`api.py`	`handle_request`、`format_response`、`health_check`
`service.py`	`build_report`、`load_user`、`load_orders`
`storage.py`	`read_cache`、`query_db`

调用关系如下，箭头始终从调用者指向被调用者：

handle_request ──→ load_user ──→ read_cache
       │               └─────→ query_db
       └────────→ format_response

build_report ───→ load_user
       └────────→ load_orders ──→ query_db

health_check    （没有调用边）

我们准备修改的函数是 query_db。从图上可以看出，load_user 和 load_orders 直接调用它；handle_request 和 build_report 则通过其他函数间接依赖它。稍后可以用查询核对。

这张图需要两类节点和两类关系。

Function：函数，保存编号 id 和名称 name。
File：文件，保存编号 id 和路径 path。
CALLS：从函数指向它调用的函数。
DEFINED_IN：从函数指向定义它的文件。

函数名只是用于展示的属性，编号才是本例的主键。实际项目可能有同名函数，不能直接用短名称判断它们是不是同一个实体。

安装与创建数据库

先创建独立的 Python 环境，再安装本文验证过的版本：

python3.11 -m venv .venv
source .venv/bin/activate
python -m pip install "neug==0.2.0"

安装方式参考官方安装指南。本文只验证了上述 macOS 环境，其他系统的安装要求请以官方文档为准。

新建一个工作目录，把下面的 Python 代码按顺序写进同一个脚本，并在该目录中运行。脚本先创建数据库目录，再打开连接：

from pathlib import Path
import neug

# 首次运行使用新目录，避免重复导入。
db_path = Path("code_graph_db")
db_path.mkdir(exist_ok=False)

db = neug.Database(str(db_path))
conn = db.connect()

再次运行完整脚本时，请换一个工作目录；exist_ok=False 会在数据库目录已存在时报错，避免误用旧数据。如果只想查询已有数据，跳过目录创建、建表和导入，直接打开原目录即可。数据库与连接说明

定义模型，再导入数据

先创建节点表和关系表：

schema = [
    "CREATE NODE TABLE Function(id INT64, name STRING, PRIMARY KEY(id))",
    "CREATE NODE TABLE File(id INT64, path STRING, PRIMARY KEY(id))",
    "CREATE REL TABLE CALLS(FROM Function TO Function)",
    "CREATE REL TABLE DEFINED_IN(FROM Function TO File)",
]
for statement in schema:
    conn.execute(statement)

FROM 和 TO 对应关系的起点和终点。例如，DEFINED_IN 从函数出发，指向文件。节点表主键和关系表的定义方式可查阅 DDL 文档。

接着准备四份 CSV。下面直接用 Python 写出文件，也可以替换成其他工具导出的 CSV。

import csv

files = [(1, "api.py"), (2, "service.py"), (3, "storage.py")]
functions = [
    (1, "handle_request"), (2, "build_report"), (3, "load_user"),
    (4, "load_orders"), (5, "read_cache"), (6, "query_db"),
    (7, "format_response"), (8, "health_check"),
]
calls = [(1, 3), (1, 7), (2, 3), (2, 4), (3, 5), (3, 6), (4, 6)]
defined_in = [(1, 1), (2, 2), (3, 2), (4, 2), (5, 3), (6, 3), (7, 1), (8, 1)]

datasets = [
    ("functions.csv", ["id", "name"], functions),
    ("files.csv", ["id", "path"], files),
    ("calls.csv", ["source", "target"], calls),
    ("defined_in.csv", ["source", "target"], defined_in),
]
for filename, header, rows in datasets:
    with open(filename, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(header)
        writer.writerows(rows)

例如，calls.csv 中的 3,6 表示编号为 3 的 load_user 调用编号为 6 的 query_db。

用 COPY FROM 导入数据，先导入节点，再导入关系：

imports = [
    "COPY Function FROM 'functions.csv' (header=true, delimiter=',')",
    "COPY File FROM 'files.csv' (header=true, delimiter=',')",
    """COPY CALLS FROM 'calls.csv'
       (header=true, delimiter=',', from='Function', to='Function')""",
    """COPY DEFINED_IN FROM 'defined_in.csv'
       (header=true, delimiter=',', from='Function', to='File')""",
]
for statement in imports:
    conn.execute(statement)

节点 CSV 的列顺序与表定义保持一致。关系 CSV 的前两列分别是起点和终点的主键值，from、to 则指定端点所属的节点表。这里的相对文件路径以运行 Python 时的工作目录为基准。CSV 导入说明

不要省略本例中的 delimiter=','。 在本次验证环境中，省略这个选项后，导入报了“识别出 1 列、预期 2 列”的错误；显式指定逗号后导入成功。

导入完成后，先核对数量：

checks = [
    "MATCH (n:Function) RETURN count(n)",
    "MATCH (n:File) RETURN count(n)",
    "MATCH (:Function)-[r:CALLS]->(:Function) RETURN count(r)",
    "MATCH (:Function)-[r:DEFINED_IN]->(:File) RETURN count(r)",
]
for query in checks:
    print(list(conn.execute(query)))

四个结果应依次是 [[8]]、[[3]]、[[7]] 和 [[8]]，对应函数数、文件数、调用边数和归属边数。如果不一致，先检查导入数据。

CSV 导入与图查询的流程示意。

第一次查询：谁直接调用了 query_db

把下面的 Cypher 交给 conn.execute()：

query = """
MATCH (caller:Function)-[:CALLS]->(target:Function {id: 6})
RETURN caller.name AS name
ORDER BY name
"""
for row in conn.execute(query):
    print(row)

输出：

['load_orders']
['load_user']

(caller:Function) 匹配函数节点，[:CALLS] 匹配调用关系，右侧的 {id: 6} 将目标限定为 query_db。这条查询只查直接调用者。

RETURN 指定要输出的属性，ORDER BY 让结果顺序稳定，方便核对。函数在 CSV 中的排列顺序不应被当作查询结果的默认排序。

第二次查询：沿调用链找到上层函数

直接调用者之外，我们还希望找到 handle_request 和 build_report。把一条边扩展为长度在 1 到 3 之间的路径：

MATCH (caller:Function)-[:CALLS*1..3]->(target:Function {id: 6})
RETURN DISTINCT caller.id AS id, caller.name AS name
ORDER BY id

将这段 Cypher 替换到上一段 Python 的 query 字符串中，保持逐行打印的代码不变，输出为：

[1, 'handle_request']
[2, 'build_report']
[3, 'load_user']
[4, 'load_orders']

*1..3 表示路径包含 1 到 3 条调用边。这张示例图的相关路径最多只有两条边，因此这个范围覆盖了图中所有上层调用者；如果某个调用者只能通过四条及以上的调用边到达目标，它就不会被返回。多跳模式语法

build_report 有两条路径能到达 query_db：一条经过 load_user，另一条经过 load_orders。DISTINCT 把重复的调用者合并。返回列保留了主键 id，即使两个函数同名，也不会被误合并。

真实调用图可能有递归和环。这里保留三层上限，限定本次查询的范围；需要追溯更深的依赖时，再调整上限。

第三次查询：这些调用者分布在哪些文件

接下来仍然替换 query 字符串，沿 DEFINED_IN 关系查出调用者所在的文件：

MATCH (caller:Function)-[:CALLS*1..3]->(target:Function {id: 6}),
      (caller)-[:DEFINED_IN]->(file:File)
RETURN DISTINCT file.path AS path
ORDER BY path

输出：

['api.py']
['service.py']

两个模式共享变量 caller：第一个模式找到上层调用者，第二个模式找到这些调用者所在的文件。

结果只包含上层调用者所在的文件，因此没有 storage.py。目标函数 query_db 自身不在这份调用者名单中；同一文件中的 read_cache 也没有调用它。如果要形成完整的改动检查清单，可以另外加入目标函数所在文件。

上一条函数查询也没有返回 format_response 和 health_check：图中没有从它们到 query_db 的调用路径。不过，调用图无法涵盖所有影响。例如，共享数据格式发生变化时，没有调用关系的代码也可能需要调整。

关闭以后，数据还在吗

完成查询后，关闭连接和数据库。随后用同一个目录重新打开：

conn.close()
db.close()

db = neug.Database(str(db_path))
conn = db.connect()
try:
    result = conn.execute("MATCH (n:Function) RETURN count(n)")
    print(list(result))  # [[8]]
finally:
    conn.close()
    db.close()

这里只重新打开数据库，不再执行建表和导入。配套脚本还会在重新打开后再次检查前面的三组查询。

本次验证覆盖了正常关闭后的重新打开，未进行进程崩溃或机器掉电测试，也没有做性能测试。八个函数的例子适合检查语法和结果，不能用来推断大型代码仓库的查询表现。

从示例走向真实代码库

接入真实代码库时，可以把这四份 CSV 换成代码分析工具的输出。导入和查询的步骤相同，数据本身则要处理好下面几个问题。

首先是身份识别。真实函数应有稳定的标识，至少要考虑仓库、文件路径和限定名称；本文的整数编号只是为了让数据容易阅读。

其次是调用关系的来源。动态分派、反射、函数指针和生成代码，都可能让关系提取出现遗漏或不确定性。将“明确解析的调用”和“推测的调用”区分开，查询结果才容易解释。

最后是版本一致性。代码更新后，需要同步替换失效的节点和关系，避免把不同版本的函数混在一张图里。

你可以先做一个小练习：在 calls 数据中增加 (8, 6)，表示 health_check 调用 query_db，然后在新的数据库中重新导入。直接调用者应增加 health_check，而文件名单仍然是 api.py 和 service.py，因为 api.py 本来就在结果中。

配套示例

配套示例包中的 demo.py 自动生成四份 CSV，在临时目录中创建数据库，核对节点和边数量，检查三组查询结果，并在正常关闭后重新打开数据库再次验证。运行结束会清理它创建的临时目录，不修改已有数据库。

python demo.py

脚本中的结果断言全部通过后，会输出 Reopen check: passed。修改示例数据后，也要相应更新 QUERIES 中的预期结果和数量断言。

参考资料

本文主要参考 NeuG 官方文档，以下链接分别对应安装、建模、导入和查询步骤。文档核对日期：2026 年 9 月 30 日；示例验证版本：NeuG 0.2.0。在线文档可能随版本更新。

NeuG — Introduction：了解 NeuG 的定位，以及嵌入式和服务两种使用方式。
NeuG — Installation：Python 安装方法及运行环境要求。
NeuG — Getting Started：创建数据库、建立连接，以及关闭连接和数据库的基本流程。
NeuG — DDL Clause：节点表、主键和关系表的定义语法。
NeuG — COPY FROM：CSV 导入、列顺序、关系端点及导入选项。
NeuG — MATCH Clause：节点与关系模式匹配，以及指定路径长度的多跳查询。
NeuG — Python Query Result：Python 查询结果对象的接口说明。

本文的代码依赖数据、查询组合和结果校验为独立编写的教学示例；具体输出以配套脚本的运行结果为依据。

读《中国通史》有感

Fri, 31 Jan 2020 09:08:22 GMT

读《中国通史》有感

这个学期末，我接触到了两本好书，《中国通史》和《历代政治得失》。今天我们主要讲吕思勉先生的《中国通史》中先秦部分。

我们常常讲，中华民族有五千年的悠久历史，其实这种说法是有争议的。国外并不承认华夏三皇五帝的存在，因为这段上古时期的历史并没有文字记载，仅存的信息是来源于民间的各种神话传说，而神话传说的真实性和准确性是有待商榷的。但是同时我们也应当明白，这世界上的任何艺术创造都是有生活来源的，即，人类所创作的文学艺术从来不可能完全脱离社会现实，不可能完全架空与社会现实。一个很典型的例子就是，人类在幻想自己从未谋面的外星人的时候，往往会给他们赋予自己曾见过的生物/事物的外形。从这个角度讲，我们有理由相信，尧舜禹的神话传说是有现实依据的。

在商朝的时候，汉字的雏形，甲骨文出现了。甲骨文的内容主要是巫师在占卜之后，将占卜的事件以及结果记录在动物的骨头上（多为牛羊的肩胛骨和龟壳）。在公元前1000年左右，位于岐山附近的周部落开始崛起，并最终以替天行道的姿态终结了商朝的统治。在我看来，周朝的最重要的人物当属周公旦，他作为周文王的弟子辅佐了周武王和周成王。他所建立的宗法制，礼乐制度成为了之后数千年中国的政治制度基础，被后世儒家尊为“元圣”。

然而分封制的弊病慢慢地耗尽了周王朝地气数，从东周开始，中原大地进入春秋战国时期。这一时期，周王室失去了对诸侯国的控制，各诸侯国为了争夺土地和人民，诉诸战争，不断变法自强，最终由秦国一同天下。客观来讲，这一时期，各诸侯过为了增强国力，广拓疆土，改革制度（导致了士阶层的出现），同时，各国之间频繁的人才流动也带动了广泛的文化交流，从而孕育了华夏文明的雏形。

LeetCode 题解-42. Trapping Rain Water

Fri, 20 Dec 2019 08:38:06 GMT

对Leetcode 42. Trapping Rain Water 题目的求解。

Problem 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.

Example 1

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

Analysis

很经典的一道题目，解决这个问题的关键点在于明白怎么样才能在一个格子里面集到最多的水．不妨假设我们想要知道在第i个格子里面最多可以集聚到多少水．那么，我们很容易发现，取决与height[i+1...n]中最大数和height[0...i-1]中最大数的较小的那个．所以，我们只需要知道左边最大和右边最大即可．那么可以有两种方案．

基于动态规划

首先从左边遍历一次数组，dp[i] = max(dp[j]) where 0<=j<=i; 同样再从右边向左遍历一次，这样，对于我们就知道左边最大和右边最大的高度了．

基于two-pointer.

设定两个指针，left, right. 初始时分别设为最左和最右．在每一次迭代中，判断height[left] 和height[right]的大小．为什么要选小的呢？因为其实我们要找的是两个最大值中的最小值，要想找到更大的最小值，自然是要舍弃现在的最小值．只有这样才能找到更大的．

Solution 1

public static int trap(int[] height) {
    if (height.length == 0) return 0;
    int left = 0;
    int right = height.length - 1;
    int maxLeft = 0;
    int maxRight = 0;
    int sum = 0;
    while (left < right){
        if (height[left] < height[right]){
            if (height[left] <= maxLeft){
                sum += maxLeft - height[left];
            }
            else {
                maxLeft = height[left];
            }
            left ++;
        }
        else {
            if (height[right] <= maxRight){
                sum += maxRight - height[right];
            }
            else {
                maxRight = height[right];
            }
            right --;
        }
    }
    return sum;
}

Solution 2

public static int trap(int[] height) {
    int dp[] = new int [height.length];
    int sum = 0;
    int max = 0;
    for (int i = 0; i < height.length; ++i){
        if (max < height[i]) max = height[i];
        dp[i] = max;
    }
    max = 0;
    for (int i = height.length-1; i >= 0; --i){
        if (max < height[i]) max = height[i];
        sum += Math.min(max, dp[i]) - height[i];
    }
    return sum;
}

Solution 3

public static int trap(int [] height){
        //using stack
        if (height.length == 0) return 0;
        Stack<Integer> s = new Stack<Integer>();
        int sum = 0;
        for (int i = 0; i < height.length; ){
            if (s.isEmpty()) s.push(i++);
            else if (height[s.peek()] >= height[i]) s.push(i++);
            else {
                int top = s.pop();
                if (!s.isEmpty()){
                    sum += (Math.min(height[s.peek()], height[i]) - height[top]) * (i - s.peek() - 1);
                }
                else continue;
            }
        }
        return sum;
    }

LeetCode 题解-42. Trapping Rain Water

Fri, 20 Dec 2019 08:38:06 GMT

Problem

Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in-place.

Example

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

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]
]

Solution 1

这道题目特别注重对空间复杂度的控制，最优的解法应当时常数空间。空间开销最大的当属O(mn). 即，遍历一遍矩阵，得到一个mxn的矩阵，其中每一个元素表示matrix上对应位置上的元素是不是应该被置为0.鉴于其过于简单，我们略去其实现。

Solution 2

在O(mxn)复杂度的基础上，我们可以将复杂度减小至O(m+n). 因为从上一种方法的实现中我们发现，其实我们并不需要记录每一个元素，只需要记录行和列的索引。

class Solution {
    public void setZeroes(int[][] matrix) {
        //O(m_n) space
        int [] rows = new int [matrix.length];
        int [] cols = new int [matrix[0].length];
        for (int i = 0; i < matrix.length; ++i){
            for (int j = 0; j < matrix[0].length; ++j){
                if (matrix[i][j] == 0){
                    rows[i] = 1;
                    cols[j] = 1;
                }
            }
        }
        for (int i = 0; i < matrix.length; ++i){
            if (rows[i] == 1){
                for (int j = 0; j < matrix[i].length; ++j){
                    matrix[i][j] = 0;
                }
            }
        }
        for (int j = 0; j < matrix[0].length; ++j){
            if (cols[j] == 1){
                for (int i = 0; i < matrix.length; ++i){
                    matrix[i][j] = 0;
                }
            }
        }
    }
}

Solution 3

有没有常数复杂度的实现呢？我很自然地想到了位运算。但是因为最大只能接受64x64地矩阵作为输入，所以失败了。在看到被人地题解后恍然大悟。O(1)的复杂度自然要求我们把信息存入到矩阵中。我们不妨征用matrix[0][...]和matrix[...][0]作为记录matrix[1..m][1...n]的置零信息。至于第0列行第0行，我们只需要2个单独的变量即可。

class Solution {
    public void setZeroes(int[][] matrix) {
        int row = 0;
        int col = 0;
        for (int i = 0; i < matrix.length; ++i){
            for (int j = 0; j < matrix[i].length; ++j){
                if (matrix[i][j] == 0){
                    if (i == 0 && col == 0) col = 1;
                    if (j == 0 && row == 0) row = 1;
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }
        for (int i = 1; i < matrix.length; ++i){
            for (int j = 1; j < matrix[i].length; ++j){
                if (matrix[0][j] == 0 | matrix[i][0] == 0) matrix[i][j] = 0;
            }
        }
        if (row == 1){
            for (int i = 0; i < matrix.length; ++i){
                matrix[i][0] = 0;
            }
        }
        if (col == 1){
            for (int i = 0; i < matrix[0].length; ++i){
                matrix[0][i] = 0;
            }
        }
    }
}

LeetCode 题解-32. Longest Valid Parentheses

Tue, 10 Dec 2019 08:51:00 GMT

对Leetcode 32. Longest Valid Parentheses 题目的求解。

Problem Description

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

Example 1

Input: "(()"
Output: 2
Explanation: The longest valid parentheses substring is "()"

Example 2

Input: ")()())"
Output: 4
Explanation: The longest valid parentheses substring is "()()"

Analysis

题目要求我们从一串由左括号和右括号组成的字符串中找出最长的有效子串，有效指well-formed,即闭合的．我们首先想到可以使用栈来判断这个串是不是闭合的，即在扫描完所有字符之后，栈是不是空的．

但是本题要求我们找出闭合的最长子串．我们可以想象，对于一个不闭合的字符串，使用栈进行扫描之后在栈里面残留的是匹配不了的元素，而可以完成匹配的子串恰恰在他们中间．因此，我们只需要在入栈的时候记录入栈字符的index,就可以计算出成功匹配的子串的长度，进而找到最大值．

Solution 1

class Solution {
    public static int longestValidParentheses(String s) {
        Stack<Integer> st = new Stack<Integer>();
        for (int i = 0; i < s.length(); ++i){
            if (s.charAt(i) == '(') st.push(i);
            else{
                if (!st.empty()){
                    if (s.charAt(st.peek()) != '(') st.push(i);
                    else st.pop();
                }
                else st.push(i);
            }   
        }
        if (st.empty()) return s.length();
        int max = 0;
        int e = s.length();
        while (!st.empty()){
            int start = st.pop();
            max = Math.max(max, e - start - 1);
            e = start;
        }
        return Math.max(max, e);
    }
}

Solution 2

如果不借助于栈，我们该怎么解决这个问题呢？联想到我们之前曾用dp的方法求解过最长连续子串的问题，与这个题目很类似，因此我们考虑如何把此题套到动态规划里面．如果我们用dp[i]来表示以s[i]结尾的最长子串的第一个字符所在位置的话，我们可以列出以下公式

if (s[i] == '(') , dp[i] = -1;
if (s[i] == ')')
- if (s[i-1] == '('), dp[i] = dp[i-2];
- if (s[i-1] == ')')
  - if (s[dp[i-1]-1] == '('), 说明s[i]可以成功匹配，dp[i] = dp[i-1]-1;
  - if (s[dp[i-1]-1] != '('), 那么dp[i] = -1

class Solution{
    public static int longestValidParentheses(String s) {
        int dp[] = new int [s.length()];
        if (s.length() <= 1) return 0;
        //dp[i] denotes the start position of the valid parentheses ended at i
        dp[0] = -1;
        if (s.charAt(1) == ')' && s.charAt(0) == '(') dp[1] = 0;
        else dp[1] = -1;
        int max = 0;
        if (dp[1] >= 0) max = Math.max(0, 2 - dp[1]);

        for (int i = 2; i < s.length(); ++i){
            if (s.charAt(i) == '(') dp[i] = -1;
            else if (s.charAt(i) == ')' && s.charAt(i-1) == '('){
                if (dp[i-2] >= 0) dp[i] = dp[i-2] ;
                else dp[i] = i-1;
            }
            else {
                // ))
                if (dp[i-1] == 0) dp[i] = -1;
                else if (dp[i-1] == -1) dp[i] = -1;
                else if (s.charAt(dp[i-1] - 1) == '('){
                    if (dp[i-1] - 2 >= 0 && dp[dp[i-1]-2] == -1) dp[i] = dp[i-1]-1;
                    else if (dp[i-1] - 2 >= 0) dp[i] = dp[dp[i-1]-2];
                    else dp[i] = dp[i-1] - 1;
                }
                else dp[i] = -1;
            }
            if (dp[i] >= 0) max = Math.max(max, i - dp[i] + 1);
        }
        for (int i = 0; i < s.length(); ++i){
            System.out.printf("%d ", dp[i]);
        }
        System.out.println();
        return max;
    }
}
``

LeetCode 题解-15. 3Sum

Thu, 05 Dec 2019 06:59:34 GMT

对Leetcode 23. Merge k Sorted Lists 题目的求解。

Problem Description

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example 1

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

Analysis

之前做过将两个linked list 合并的题目，即为归并排序的思路，这道题要求我们将k个排好序的链表做归并．有两种思路

将k个list的归并不断分解为两个list的归并，即采用二分的方法
采用最直观的思路，既然k个列表都是排好序的，那么在任何时刻，表头的元素都是当前最小的元素．可以使用priority queue来找到最小的元素，并且更换表头．

Solution 1

class Solution {
    public static ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) return null;
        return part(lists, 0, lists.length - 1);
    }
    public static ListNode part(ListNode[] lists,int s, int t) {
        if (s == t) return lists[s];
        ListNode l1 = part(lists, s, (s+t)/2);
        ListNode l2 = part(lists, (s+t)/2+1, t);
        return merge(l1, l2);
    }
    public static ListNode merge(ListNode l1, ListNode l2){
        ListNode zero = new ListNode(0);
        ListNode tmp = zero;
        while (l1 != null && l2 != null){
            if (l1.val < l2.val){ tmp.next = l1; l1 = l1.next;}
            else {tmp.next = l2; l2 = l2.next;}
            tmp = tmp.next;
        }
        while (l1 != null) {tmp.next = l1; l1 = l1.next; tmp = tmp.next;}
        while (l2 != null) {tmp.next = l2; l2 = l2.next; tmp = tmp.next;}
        return zero.next;
    }
}

Solution 2

class Solution{
        public static ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) return null;
        //priority queue
        PriorityQueue<ListNode> q = new PriorityQueue<ListNode>(lists.length, 
            new Comparator<ListNode>() {
                @Override
                public int compare(ListNode l1, ListNode l2){
                    if (l1.val < l2.val){
                        return -1;
                    }
                    else if (l1.val > l2.val){
                        return 1;
                    }
                    else return 0;
                }
            }
        );
        for (ListNode l : lists){
            if (l != null) q.add(l);
        }
        ListNode zero = new ListNode(0);
        ListNode tmp = zero;
        while (!q.isEmpty()){
            ListNode l = q.poll();
            tmp.next = l;
            tmp = tmp.next;
            if (l.next != null) q.add(l.next);
        }
        return zero.next;

    }
}

Solution 3

class Solution {
    public static ListNode mergeKLists(ListNode[] lists) {
        if (lists.length ==0) return null;
        ListNode zero = new ListNode(0);
        ListNode tmp = zero;
        while (true){
            ListNode min_node = find_min_node(lists);
            if (min_node == null) break;
            tmp.next = min_node;
            tmp = tmp.next;
        }
        return zero.next;
    }
    public static ListNode find_min_node(ListNode[] lists) {
        ListNode res = help(lists, 0, lists.length-1);
        if (res == null) return null;
        for (int i = 0; i < lists.length; ++i){
            //System.out.print(res);
            //System.out.println(lists[i]);
            if (res.equals(lists[i])){
                lists[i] = res.next;
                break;
            }
        }
        return res;
    }
    public static ListNode help(ListNode[] lists, int s, int t){
        //System.out.printf("%d %d\n", s, t);
        if (s == t) return lists[s];
        ListNode l1 = help(lists, s, (t+s)/2);
        ListNode l2 = help(lists, (t+s)/2 + 1, t);
        if (l1 == null && l2 == null ) return null;
        if (l1 == null) return l2;
        if (l2 == null) return l1;
        if (l1.val < l2.val) return l1;
        else return l2;
    }

LeetCode 题解-31. Next Permutation

Thu, 05 Dec 2019 05:59:11 GMT

对Leetcode 31. Next Permutation 题目的求解。

Problem 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.

Example 1

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

Analysis

对n个元素的集合我们进行排列，叫permutation. 对于排列的集合，我们可以按照字母序(lexicographically)进行排序．而这道题目就要求我们在给定一个排列的情况下，找到它下一个排列．

首先我们需要认清一个排列的规律．

字母序排序的第一个排列是n个元素的升序排列，最后一个排列是n个元素的降序排列．
所以我们可以把每个排列分成两半，前一半不一定．而后一半一定是降序的，．

那么我们如果得到字典序的下一个排列呢．首先，找出这两个半相交的地方，即index最大的出现顺序的地方．在此之后是降序列．我们要使得排列变得更大，就要排列出更大的降序列，所以要将这个顺序对变成降序．那么要变成怎么样的降序呢？当然是比当前大的排列里最小的．那么，我们就需要找出他之后的元素里比他大的最小的，进行swap,之后将后面的元素进行排序，得到新子集合的最小排列．

Solution 1

class Solution {
    //1. first find the smallest ascending order(wrong)
    //2, we should find adjacent elements in ascending order.
    for (int i = nums.length-1;  i >= 1; --i){
        if (nums[i] > nums[i-1]){
            for (int j = nums.length - 1; j >= i; --j){
                if (nums[j] > nums[i-1]){
                    int tmp = nums[i-1];
                    nums[i-1] = nums[j];
                    nums[j] = tmp;
                    Arrays.sort(nums, i, nums.length);
                    return ;
                }
            }
        }
    }
    int tmp = 0;
    for (int i = 0; i < nums.length/2; ++i){
        tmp = nums[i];
        nums[i] = nums[nums.length - i - 1];
        nums[nums.length - i - 1] = tmp;
    }
}

LeetCode 题解-15. 3Sum

Tue, 03 Dec 2019 09:05:50 GMT

对Leetcode 15. 3Sum 题目的求解。

Problem Description

Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

The solution set must not contain duplicate triplets.

Example 1

Given array nums = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

Analysis

这是一道two-pointer的题目．通过O(n)的遍历将自由度为3的搜索题目降到自由度为2.由此我们可以转化为2sum的问题．至于如何解决2sum的问题，我们首先进行排序，再使用two pointer进行搜索，总的复杂度为O(n^2).

Solution

class Solution {
    public static List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new LinkedList<>();
        int s = 0;
        int t = 0;
        for (int i = 0; i < nums.length - 2; ++i){
            if (i > 0 && nums[i] == nums[i-1]) continue;
            s = i + 1;
            t = nums.length - 1;
            while ( s < t){
                if (s > i+1 && t < nums.length - 1 && nums[s] == nums[s-1] && nums[t] == nums[t+1]){
                    s ++;
                    t --;
                    continue;
                }
                if (nums[s] + nums[t] == - nums[i]){
                    LinkedList<Integer> l = new LinkedList<>();
                    l.add(nums[i]);
                    l.add(nums[s]);
                    l.add(nums[t]);
                    res.add(l);
                    s ++;
                    t --;
                }
                else if (nums[s] + nums[t] > - nums[i]) t --;
                else s ++;
            }
        }
        return res;
    }
}

LeetCode 题解-18. 4Sum

Tue, 03 Dec 2019 09:05:50 GMT

对Leetcode 18. 4Sum 题目的求解。

Problem Description

Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

The solution set must not contain duplicate triplets.

Example 1

Given array nums = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

Analysis

Solution

class Solution {
    public static List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new LinkedList<>();
        int s = 0;
        int t = 0;
        for (int i = 0; i < nums.length - 2; ++i){
            if (i > 0 && nums[i] == nums[i-1]) continue;
            s = i + 1;
            t = nums.length - 1;
            while ( s < t){
                if (s > i+1 && t < nums.length - 1 && nums[s] == nums[s-1] && nums[t] == nums[t+1]){
                    s ++;
                    t --;
                    continue;
                }
                if (nums[s] + nums[t] == - nums[i]){
                    LinkedList<Integer> l = new LinkedList<>();
                    l.add(nums[i]);
                    l.add(nums[s]);
                    l.add(nums[t]);
                    res.add(l);
                    s ++;
                    t --;
                }
                else if (nums[s] + nums[t] > - nums[i]) t --;
                else s ++;
            }
        }
        return res;
    }
}

LeetCode 题解-10. Regular Expression Matching

Mon, 02 Dec 2019 06:18:49 GMT

对Leetcode 10. Regular Expression Matching 题目的求解。

Problem Description

Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.
'*' Matches zero or more of the preceding element. The matching should cover the entire input string (not partial).

Note:

s could be empty and contains only lowercase letters a-z.
p could be empty and contains only lowercase letters a-z, and characters like . or *.

Example 1

Input :
s = "aa"
p = "a"
Output: false
Explanation: "a" does not match the entire string "aa".

Example 2

Input:
s = "aa"
p = "a*"
Output: true
Explanation: '*' means zero or more of the preceding element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".

Example 3

Input:
s = "ab"
p = ".*"
Output: true
Explanation: ".*" means "zero or more (*) of any character (.)".

Example 4

Input:
s = "aab"
p = "c*a*b"
Output: true
Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore, it matches "aab".

Example 5

Input:
s = "mississippi"
p = "mis*is*p*."
Output: false

Analysis

这道题目要求我们实现一个正则匹配的引擎，包括*和.．我刚开始想用贪心匹配解决，发现不能解决全串匹配的问题，也就是说，贪心匹配不保证我们考虑到所有可能的情况．根据leetcode discussion提供的思路，我们使用动态规划的方法解决此问题．

我们开辟二维数组dp[i][j]来表示我们是否可以用p[0...j]的正则表达式成功匹配s[0...i]的字符串．递归公式我们可以这样考虑．假设我们在dp[i][j]之前已经计算好了dp[0...i-1][0..j-1]. 至于dp[i][j],我们考虑三种不同的情况，

1. s[i] == p[j]. 那么如果我们就可以继承dp[i-1][j-1].
1. p[j] == '.', 同样，我们可以继承dp[i-1][j-1].
1. p[j] == '*'. 这意味着p[j-1] 是[a-z]的字符．所以我们需要将讨论p[j-1]与s[i]的关系．
- p[j-1] == '.' 或 p[j-1] == s[i]. 在这种情况下，我们可以有不同的可能，只要有一种可能能够成功匹配，我们就能成功匹配．　如果我们不适用`[a-z|.]*'进行匹配，结果是dp[i][j] = dp[i][j-2]. 如果我们只匹配一次，dp[i][j] = dp[i][j-1]. (相当于不用*); 如果我们匹配多次，dp[i][j] = dp[i-1][j].
- p[j-1] 不能和s[i]进行匹配，即匹配失败．所以，dp[i][j] = dp[i][j-2];

最终返回dp[i][j]即为结果．

Solution

需要注意的是在初始化的时候需要初始化dp[0][0..j].

class Solution {
    public static boolean isMatch(String s, String p){
        int dp[][] = new int [s.length()+1][p.length()+1];
        dp[0][0] = 1;
        for (int i = 1; i <= p.length(); ++i){
            if (p.charAt(i-1) == '*') dp[0][i] = dp[0][i-2];
        }
        for (int i = 1; i <= s.length(); ++i){
            for (int j = 1; j <= p.length(); ++j){
                if (p.charAt(j-1) == s.charAt(i-1)){
                    dp[i][j] = dp[i-1][j-1];
                }
                else if (p.charAt(j-1) == '.'){
                    dp[i][j] = dp[i-1][j-1];
                }
                else if (p.charAt(j-1) == '*'){
                    //in this condition, we have to check dp[i-1][j-1] and dp[i][j-1] and dp[i-1][j]
                    if (p.charAt(j-2) == s.charAt(i-1) || p.charAt(j-2) == '.') {
                        dp[i][j] = dp[i][j-2] | dp[i-1][j] | dp[i][j-1];
                                // no matches | multiple matches | single match
                    }
                    else dp[i][j] = dp[i][j-2];
                }
                //default 0
            }
        }
        // for (int i = 0; i < s.length(); ++i){
        //     for (int j = 0; j < p.length(); ++j){
        //         System.out.printf("%d ", dp[i][j]);
        //     }
        //     System.out.println();
        // }
        if (dp[s.length()][p.length()] == 1) return true;
        return false;
    }
}

LeetCode 题解-494. Target Sum

Mon, 02 Dec 2019 06:18:49 GMT

对Leetcode 494. Target Sum 题目的求解。

Problem Description

You are given a list of non-negative integers, a1, a2, ..., an, and a target, S. Now you have 2 symbols + and -. For each integer, you should choose one from + and - as its new symbol.

Find out how many ways to assign symbols to make sum of integers equal to target S.

Example 1

Input: nums is [1, 1, 1, 1, 1], S is 3. 
Output: 5
Explanation: 

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

There are 5 ways to assign symbols to make the sum of nums be target 3.

Note

The length of the given array is positive and will not exceed 20. The sum of elements in the given array will not exceed 1000. Your output answer is guaranteed to be fitted in a 32-bit integer.

Analysis

第一反应这道题是搜索题，因为题目很明显地提到了一个target sum 和每个元素的两条分支，所以我们可以写出基于深度有限搜索的solution 1, 时间复杂度为O(2^n).

Solution 1: bfs with recursive call

class Solution {
    public static int findTargetSumWays(int[] nums, int S) {
        return help(nums, S, 0);
    }
    public static int help(int[] nums, int S, int start){
        if (start > nums.length - 1) return 0;
        if (start == nums.length - 1 && nums[start] == 0 && nums[start] == S) return 2;
        else if (start == nums.length - 1 && nums[start] == S) return 1;
        else if (start == nums.length - 1 && nums[start] == -S) return 1;
        return help(nums, S - nums[start], start + 1) + help(nums, S + nums[start], start + 1);
    }
}

Analysis 2

但事实上，这道题是一道背包问题．对于每个元素我们有两种选项，+或-．暴力破解的方法复杂度太高，我们考虑更高效的方法．我们首先可以把+,-两个符号换一种角度看待，可以看做将数组分为两半，用其中一般取减去另外一半得到target.

因此

sum(p) - sum(n) = S
2sum(p) = S + sum(p&n)
sum(p) = (S + sum(p&n))/2

所以我们只需要找到子数组，是的其和为$(S + sum(p&n))/2$即可．由于题目中已经指出数组中所有元素之和不超过1000,所以我们可以构造dp[1-1000],dp[i]表示有多少种组合可以构成sum为i的子数组．

Solution 2

class Solution{
    public static int findTargetSumWays(int[] nums, int S){
        int sum = 0;
        for (int num : nums) sum += num;
        if (sum < S) return 0;
        if ((sum+S) % 2 == 1) return 0;
        //because in this case it is not possible
        int target = (sum + S)/2;

        int dp[] = new int [target+1];
        dp[0] = 1;
        for (int i = 0; i < nums.length; ++i){
            for (int j = target; j >= nums[i]; --j){
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[target];
    }
}

LeetCode 题解-283. Move Zeroes

Sun, 01 Dec 2019 06:03:12 GMT

对Leetcode 283. Move Zeroes 题目的求解。

Problem Description

Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.

Example 1

Input: [0,1,0,3,12]
Output: [1,3,12,0,0]

Note

You must do this in-place without making a copy of the array.
Minimize the total number of operations.

Analysis

题目要求我们要in-place,所以我们不能开辟新的空间．这道题我们使用快慢指针．快指针指向当前元素，慢指针指向新数组的当前元素．

Solution

class Solution {
    public static void moveZeroes(int[] nums) {
        int cur = 0;
        for (int i = 0; i < nums.length; ++i){
            if (nums[i] != 0){
                nums[cur++] = nums[i];
            }
        }
        for (int i = cur; i < nums.length; ++i){
            nums[i] = 0;
        }
    }
}

LeetCode 题解-152. Maximum Product Subarray

Thu, 28 Nov 2019 08:24:51 GMT

对Leetcode 152. Maximum Product Subarray 题目的求解。

Problem Description

Given an integer array nums, find the contiguous subarray within an array (containing at least one number) which has the largest product.

Example 1

Input: [2,3,-2,4]
Output: 6
Explanation: [2,3] has the largest product 6.

Example 2

Input: [-2,0,-1]
Output: 0
Explanation: The result cannot be 2, because [-2,-1] is not a subarray.

Solution 1: brute force

计算出每个可能的subarray的product,选择最大的．时间复杂度为O(n^2).需要注意的是只需要开O(n)的数组即可．

class Solution {
    public static int maxProduct(int[] nums) {
        int dp[] = new int [nums.length];
        int max = -10000;
        for (int i = nums.length - 1; i >= 0; --i){
            for (int j = i; j < nums.length; ++j){
                if (j == i) dp[j] = nums[j];
                else dp[j] = dp[j-1] * nums[j];
                max= Math.max(max, dp[j]);
            }
        }
        return max;
    }
}

Solution 2 : optimized

我们想想有没有可能在线性时间内解决问题呢？如果我们使用dp[i]来表示以nums[i]结尾的最大的product呢？然而这样简单的做法是不行的．因为我们的数组中会出现负数．例如[2,-2,-4].最大的乘积是16但是按照简单的dp只能得到8.　深入观察可以发现，我们之所以得不到最大解是因为在中间结果中存在很小的负数再乘以负数变得很大的情况．既然这样，我们就维护两个数组，分别存储最大的数和最小的数．

class Solution {
    public static int maxProduct(int[] nums) {
        if (nums.length == 1) return nums[0];
        int dp_max[] = new int [nums.length+1];
        int dp_min[] = new int [nums.length+1];
        int max = -10000;
        for (int i = 1; i <= nums.length; ++i){
            dp_max[i] = Math.max(Math.max(nums[i-1], dp_max[i-1] * nums[i-1]), dp_min[i-1] * nums[i-1]);
            dp_min[i] = Math.min(Math.min(nums[i-1], dp_max[i-1] * nums[i-1]), dp_min[i-1] * nums[i-1]);
            max=Math.max(max, dp_max[i]);
        }
        return max;
    }
}

LeetCode 题解-371. Sum of Two Integers

Thu, 28 Nov 2019 08:15:40 GMT

对Leetcode 371. Sum of Two Integers 题目的求解。

Problem Description

Calculate the sum of two integers a and b, but you are not allowed to use the operator + and -.

Example 1

Input: a = 1, b = 2
Output: 3

Example 2

Input: a = -2, b = 3
Output: 1

Analysis

在不使用内置加法运算的情况下求两个数的和，我们需要依赖位运算．在位运算中我们需要关注两种运算

异或．两个数异或的结果恰恰是不进位加法的结果．
与．两个数与运算后的结果恰恰是进位的结果．

所以对于a+b,我们求得异或和与的结果之后，再将两个结果相加，长此以往，直到其中一个为零：没有进位了，或者加法结果恰好为2^n．

Solution 1: bfs with recursive call

class Solution{
    public static int getSum(int a, int b) {
        while (a != 0 && b != 0){
            int tmp = a ^ b;
            b = (a & b) << 1;
            a = tmp;
            //System.out.printf("%d %d\n", a, b);
        }
        if (a == 0) return b;
        else return a;
    }
｝

LeetCode 题解-136. Single Number

Thu, 28 Nov 2019 05:39:12 GMT

对Leetcode 136. Single Number 题目的求解。

Problem Description

Given a non-empty array of integers, every element appears twice except for one. Find that single one.

Example 1

Input: [2,2,1]
Output: 1

Example 2

Input: [4,1,2,1,2]
Output: 4

Solution 1: brute force

时间复杂度为线性．

class Solution {
    public static int singleNumber(int[] nums) {
        Map<Integer,Integer> m = new HashMap<Integer, Integer>();
        for (int num : nums){
            m.put(num, m.getOrDefault(num, 0)+1);
        }
        for (int num : m.keySet()){
            if (m.get(num) == 2) continue;
            if (m.get(num) == 1) return num;
        }
        return 0;
    }
}

Solution 2: bit operation

时间复杂度为线性，利用了相同的数异或为0的特点．

class Solution {
    public static int singleNumber(int[] nums) {
        int res = 0;
        for (int num : nums){
            res = res ^ num;
        }
        return res;
    }
}

拓展

有一个 n 个元素的数组，除了两个数只出现一次外，其余元素都出现两次，让你找出这两个只出现一次的数分别是几，要求时间复杂度为 O(n) 且再开辟的内存空间固定(与 n 无关)。

Solution

如果我们按照前面提到的方法对所有元素求异或的话，我们是得不到最后答案的，因为我们得到的结果是这两个数的异或，那么我们想到，再遍历一次数组，对每个元素单独再异或，只可能有三种结果，其中只会出现一次的两个结果即为我们想要的答案．

class Solution{
    public static int singleNumber(int [] nums){
        int res = 0;
        for (int num : nums){
            res = res ^ num;
        }
        Map<Integer,Integer> m = new HashMap<Integer, Integer>();
        for (int num : nums){
            int tmp = res ^ num;
            m.put(num, m.getOrDefault(num, 0) + 1);
        }
        for (int num : m.keySet()){
            if (m.get(num) == 1) System.out.printf("%d \n", num);
        }
        return 0;
    }
}

LeetCode 题解-5. Longest Palindromic Substring

Tue, 26 Nov 2019 03:37:02 GMT

对Leetcode 5. Longest Palindromic Substring 题目的求解。

Problem 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

Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2

Input: "cbbd"
Output: "bb"s

Analysis

这道题的题意为从字符串的子串中找出最长的回文串．而回文可以递归定义，所以我们可以靠动态规划来解决这个问题．复杂度为O(n^2).

Solution 1: dp

class Solution {
    public static String longestPalindrome(String s) {
        int l = s.length();
        if (l == 0) return s;
        int max = 0;
        int max_i = 0;
        int max_j = 0;
        int dp[][] = new int [l][l];
        for (int i = 0; i < l; ++i){
            dp[i][i] = 1;
        }
        for (int i = 1; i <= l - 1; ++i){
            for (int j = 0; j < l - i; ++j){
                if (s.charAt(j) == s.charAt(j+i)){
                    if (i == 1) dp[j][j+i] = 1;
                    else dp[j][j+i] = dp[j+1][j+i-1];
                }
                if (dp[j][j+i] == 1){
                    if (i + 1 > max){
                        max = i + 1;
                        max_i = j;
                        max_j = j+i;
                    } 
                }
            }
        }
        return s.substring(max_i, max_j+1);
    }
}

Solution 2: dfs solution with stack

还有一种思路就是先选定回文的中心，在进行扩展，遍历所有可能的中心得到最长的结果．

public static String longestPalindrome(String s) {
    //each palindrome is centered
    if (s.length() == 0) return s;
    int l = 0;
    int r = 0;
    int max_l = 0; int max_r = 0; int max_ = 0;
    for (int i = 0; i < s.length() - 1; ++i){
        //extend(i, i, )
        l = i;r = i;
        while ( l >= 0 && r <= s.length() - 1 && s.charAt(l) == s.charAt(r)) {
            l --; r ++;
        }
        if (max_ < r - l - 1){
            max_ = r - l - 1;
            max_l = l+1; max_r = r-1;
        }
        //extent(i,i+1)
        l = i;r = i+1;
        while ( l >= 0 && r <= s.length() - 1 && s.charAt(l) == s.charAt(r)) {
            l --; r ++;
        }
        if (max_ < r - l - 1){
            max_ = r - l - 1;
            max_l = l+1; max_r = r-1;
        }
    }
    return s.substring(max_l, max_r+1);
}

LeetCode 题解-200. Number of Islands

Tue, 26 Nov 2019 02:39:33 GMT

对Leetcode 200. Number of Islands 题目的求解。

Problem Description

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1

Input:
11110
11010
11000
00000

Output: 1

Example 2

Input:
11000
11000
00100
00011

Output: 3

Analysis

这道题目的本质就是求矩阵中连续区域的个数．很简单的想法就是用图搜索的方法来探索整个矩阵，将所有访问过的位置全部标为０以免下次在访问．在bfs的实现中，我们需要借助queue，在dfs的实现中，我们可以使用递归，也可以使用stack.

Solution 1: bfs with recursive call

class Solution {
    public static int numIslands(char[][] grid) {
        if (grid.length ==0 || grid[0].length == 0) return 0;
        int cnt = 0;
        for (int i = 0; i < grid.length; ++i){
            for (int j = 0; j < grid[i].length; ++j){
                if (grid[i][j] == '1'){
                    dfs(i,j,grid);
                    cnt += 1;
                }
            }
        }
        return cnt;
    }
    public static void dfs(int i, int j, char[][] grid){
        if (i < 0 || j < 0 || i > grid.length - 1 || j > grid[i].length - 1 || grid[i][j] == '0') return ;
        grid[i][j] = '0';
        dfs(i+1, j ,grid);
        dfs(i, j+1 ,grid);
        dfs(i, j-1 ,grid);
        dfs(i-1, j ,grid);
    }
}

Solution 2: dfs solution with stack

class Solution{
    public static int numIslands(char[][] grid) {
        if (grid.length ==0 || grid[0].length == 0) return 0;
        int cnt = 0;
        Stack<Pair> s = new Stack<Pair>();
        for (int i = 0; i < grid.length; ++i){
            for (int j = 0; j < grid[i].length; ++j){
                if (grid[i][j] == '1'){
                    System.out.printf("%d %d\n", i, j);
                    s.push(new Pair(i,j));
                    while (!s.isEmpty()){
                        Pair p = s.pop();
                        grid[p.x][p.y] = '0';
                        if (p.x+1 < grid.length && grid[p.x+1][p.y] == '1') s.push(new Pair(p.x+1,p.y));
                        if (p.y+1 < grid[0].length && grid[p.x][p.y+1] == '1') s.push(new Pair(p.x,p.y+1));
                        if (p.x-1 >= 0 && grid[p.x-1][p.y] == '1') s.push(new Pair(p.x-1,p.y));
                        if (p.y-1 >= 0 && grid[p.x][p.y-1] == '1') s.push(new Pair(p.x,p.y-1));
                    }
                    cnt += 1;
                }
            }
        }
        return cnt;
    }
}

Solution 3 bfs

class Solution{
    private static class Pair{
        int x ;
        int y ;
        public Pair(int xx, int yy){this.x = xx; this.y = yy;}
        //public Pair(){this.x = -1; this.y = -1;}
    }
    public static int numIslands(char[][] grid) {
        //dfs?
        if (grid.length == 0 || grid[0].length == 0) return 0;
        int flag[][] = new int [grid.length][grid[0].length];
        Stack<Pair> s = new Stack<Pair>();
        int cur_i = 0;
        int group = 0;
        while (true){
            for (int i = cur_i; i < grid.length; ++i){
                for (int j = 0; j < grid[i].length; ++j){
                    //System.out.printf("a:%d %d\n", i, j);
                    if (grid[i][j] == '1' && flag[i][j] == 0){
                        Pair tmp = new Pair(i,j);
                        s.push(tmp);
                        flag[i][j] = 1;
                        cur_i = i;
                        break;
                    }
                }
                if (!s.isEmpty()){
                    break;
                }
            }
            if (s.isEmpty()) break;
            while (!s.isEmpty()){
                Pair p = s.pop();
                if (p.x+1 < grid.length && flag[p.x+1][p.y] == 0 && grid[p.x+1][p.y] == '1'){
                    Pair tmp = new Pair (p.x + 1, p.y);
                    s.push(tmp);
                    flag[p.x+1][p.y] = 1;
                }
                if (p.x-1 >= 0 && flag[p.x-1][p.y] == 0 && grid[p.x-1][p.y] == '1'){
                    Pair tmp = new Pair (p.x - 1, p.y);
                    s.push(tmp);
                    flag[p.x-1][p.y] = 1;
                }
                if (p.y+1 < grid[0].length && flag[p.x][p.y+1] == 0 && grid[p.x][p.y+1] == '1'){
                    Pair tmp = new Pair(p.x, p.y + 1);
                    s.push(tmp);
                    flag[p.x][p.y+1] = 1;
                }
                if (p.y-1 >= 0 && flag[p.x][p.y-1] == 0 && grid[p.x][p.y-1] == '1'){
                    Pair tmp = new Pair (p.x, p.y-1);
                    s.push(tmp);
                    flag[p.x][p.y-1] = 1;
                }
            }
            group += 1;
        }
        return group;
    }
}

Solution 4: Union find

class Solution{
    public static int numIslands(char[][] grid) {
        //union search
        if (grid.length == 0 || grid[0].length == 0) return 0;
        Pair[][] father = new Pair [grid.length][grid[0].length];
        for (int i = 0; i < grid.length; ++i){
            for (int j = 0; j < grid[0].length; ++j){
                if (grid[i][j] == '1'){
                    father[i][j] = new Pair(i,j);
                }
                else father[i][j] = new Pair(-1, -1);
            }
        }
        for (int i = 0; i < grid.length; ++i){
            for (int j = 0; j < grid[i].length; ++j){
                if (grid[i][j] == '0') continue;
                if (i + 1 < grid.length && grid[i+1][j] == '1' &&(findroot(i, j, father).x != findroot(i+1, j, father).x || findroot(i, j, father).y != findroot(i+1, j, father).y)){
                    join(findroot(i, j, father), findroot(i+1, j, father));
                }
                if (j + 1 < grid[i].length && grid[i][j+1] == '1' && (findroot(i, j, father).x != findroot(i, j+1, father).x || findroot(i, j, father).y != findroot(i, j+1, father).y)){
                    join(findroot(i, j, father), findroot(i, j+1, father));
                }
                if (i - 1 >= 0 && grid[i-1][j] == '1' && (findroot(i, j, father).x != findroot(i-1, j, father).x || findroot(i, j, father).y != findroot(i-1, j, father).y)){
                    join(findroot(i, j, father), findroot(i-1, j, father));
                }
                if (j - 1 >= 0 && grid[i][j-1] == '1' && (findroot(i, j, father).x != findroot(i, j-1, father).x || findroot(i, j, father).y != findroot(i, j-1, father).y)){
                    join(findroot(i, j, father), findroot(i, j-1, father));
                }
                // for (int ii = 0; ii < grid.length; ++ii){
                //     for (int jj = 0; jj < grid[0].length; ++jj){
                //         System.out.printf("[%d %d] ", father[ii][jj].x, father[ii][jj].y);
                //     }
                //     System.out.println();
                // }
                // System.out.println();
            }
        }
        int group = 0;
        for (int i = 0; i < grid.length; ++i){
            for (int j = 0; j < grid[i].length; ++j){
                if (father[i][j].x == i && father[i][j].y ==j){
                    group += 1;
                }
            }
        }
        return group;
    }
    public static Pair findroot(int i, int j, Pair[][] father){
        //System.out.printf("%d %d\n", i,j);
        while (father[i][j].x != i || father[i][j].y != j){
            int tmp = i;
            i = father[i][j].x;
            j = father[tmp][j].y;
            //System.out.printf("%d %d\n", i,j);
        }
        return father[i][j];
    }
    public static void join(Pair f1, Pair f2) {
        f2.x = f1.x;
        f2.y = f1.y;
    }
}

LeetCode 题解-516.longest-palindromic-subsequence

Tue, 26 Nov 2019 02:39:33 GMT

对Leetcode 516.longest-palindromic-subsequence 题目的求解。

Problem Description

Given a string s, find the longest palindromic subsequence's length in s. You may assume that the maximum length of s is 1000.

Example 1

Input:
"bbbab"
Output:
4

Example 2

Input:

"cbbd"
Output:
2

Analysis

这道题目和第5题类似，不过第五题中我们考虑的时候包含区间头尾的回文串，而在这道题目中，我们需要考虑区间内的最长回文串，是一道很明显的动态规划题目，递归公式为

dp[i][j] = max(dp[i+1][j], dp[i][j-1]) if s[i] neq s[j]
dp[i][j] = max(dp[i+1][j], dp[i][j-1], dp[i+1][j-1]+2) if s[i] eq s[j]

Solution 1: bfs with recursive call

class Solution {
    public static int longestPalindromeSubseq(String s) {
        int l = s.length();
        if (l == 0) return 0;
        int dp[][] = new int [l][l];
        //int start = 0;
        for (int i = l-1; i >= 0; --i){
            for (int j = i; j < l ; ++j){
                //System.out.printf("%d %d\n", i, j);
                if (i == j) dp[i][j] = 1;
                //dp[i][j] = Math.max(dp[i][i+len-2], dp[i+1][i+len]);
                else if (s.charAt(i) == s.charAt(j)){
                    dp[i][j] = dp[i+1][j-1]+2;
                }
                else dp[i][j] = Math.max(dp[i][j-1], dp[i+1][j]);
            }
        }
        return dp[0][l-1];

    }
}

LeetCode 题解-11. Container With Most Water

Mon, 18 Nov 2019 12:01:31 GMT

对Leetcode 11. Container With Most Water 题目的求解。

Problem 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.

Example 1


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

Analysis

这道题虽然代码简单，但是要求我们具有足够的观察能力和分析能力得出规律．首先，最简单的方法就是暴力求解，遍历长度为1-n的所有情况，复杂度为O(n^2).

我们现在试着找些规律．假设给定的lines为[a,b,...,c,d].首先长度为n的container的最大容积只能是(a,d).对于长度为n-1的两个容器，我们观察可知，只有将较短的那根线向内移动，才有可能得到更大的容积，否则不会超过n时候的情况（木桶效应）．依次类推，我们每次移动较短的那块板，以寻求更大的容积．

但是我们好像忽略了一种情况，假如a<d,那么我们下一步会取[b,...,c,d]那么有没有可能在[a,b,...,c]中取得较高值的可能呢？答案是否定的．如果在后者有更高的值，那么肯定有一条边是a,假设另外一条边是e,如果a<e，那么最大的面积实际上应该在[a,d]取得．如果a>=e，那么e<=a<d,最大的面积也是在[a,d]取到．反证结束．

Solution 1

class Solution {
    public static int maxArea(int[] height) {
        int max = 0;
        int l = 0;
        int r = height.length - 1;
        while ( l < r){
            max = Math.max( Math.min(height[l], height[r]) * (r - l), max);
            if (height[l] < height[r]){
                l++;
            }
            else {
                r--;
            }
        }
        return max;
    }
}

LeetCode 题解-4. Median of Two Sorted Arrays

Mon, 18 Nov 2019 05:52:01 GMT

对Leetcode 4. Median of Two Sorted Arrays 题目的求解。

Problem 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)).

You may assume nums1 and nums2 cannot be both empty.

Example 1


nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

Analysis

这道题是leetcode上第一道hard题目，其困难主要在于题意的理解和边界情况的处理上。

题意理解

首先，我们要换一种方式来理解中位数。对于中位数，我们有两种理解

通过中位数可以将数组分为两半，使得前一半的元素都小于后一半的元素。
中位数即为第len/2个元素。

事实上，从两种不同的理解出发，我们可以得到两种不同的解法。基于第一种理解，我们可以不断进行二分查找，找到中间元素.而对于第二种理解，我们可以从两个数组的头部出发，寻找第len/2个元素．我们首先列出第二种理解对应的解法．其中index表示我们要在两个列表联合构成的集合中要找到的第index个元素．

边界情况分析

Solution 1


public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        if ( (m + n)% 2 == 0){
            int l = helper(nums1, nums2, 0, m-1, 0, n-1, (m+n)/2);
            int r = helper(nums1, nums2, 0, m-1, 0, n-1, (m+n)/2+1);
            //System.out.printf("%d %d", l, r);
            return ((double)l + r)/2;
        }
        else {
            return helper(nums1, nums2, 0, m-1, 0, n-1, (m+n)/2+1);
        }
    }
    public static int helper(int[] nums1, int []nums2, int s1, int e1, int s2, int e2, int index){
        if (s1 > e1){
            return nums2[s2 + index - 1];
        }
        else if (s2 > e2){
            return nums1[s1 + index - 1];
        }
        if (index == 1){
            return Math.min(nums1[s1], nums2[s2]);
        }
        int mid1 = s1 + index / 2 - 1;
        int mid2 = s2 + index / 2 - 1;
        if (mid1 > e1 ) return helper(nums1, nums2, s1, e1, mid2+1, e2, index - index/2);
        else if (mid2 > e2) return helper(nums1, nums2, mid1+1, e1, s2, e2, index - index/2);
        if (nums1[mid1] <= nums2[mid2]){
            return helper(nums1, nums2, mid1+1, e1, s2, e2, index - index/2);
        }
        else {
            return helper(nums1, nums2, s1, e1, mid2+1, e2, index - index/2);
        }
    }

Solution 2

Brute force,相当于merge sort

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int nums3[] = new int [nums1.length + nums2.length];
        int i = 0, j = 0, z = 0;
        for (; i < nums1.length && j < nums2.length;){
            if (nums1[i] <= nums2[j]){
                nums3[z++] = nums1[i++];
            }
            else nums3[z++] = nums2[j++];
        }
        for (;i < nums1.length; ++i){
            nums3[z++] = nums1[i];
        }
        for (;j < nums2.length; ++j){
            nums3[z++] = nums2[j];
        }

        if (nums3.length % 2 == 0){
            return (double)(nums3[nums3.length / 2 - 1] + nums3[nums3.length / 2]) / 2;
        }
        else return (double)nums3[nums3.length / 2];
    }

Solution 3

LeetCode 题解-221. Maximal Square

Wed, 13 Nov 2019 12:50:12 GMT

对Leetcode 221. Maximal Square 题目的求解。

Problem Description

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

Example

Input:
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

Output: 4

Analysis

看到网格类题目，首先想到动态规划。既然要用动态规划，我们必须要找到递归规律。我们很自然的想到，用dp[i][j]表示以(i,j)为右下角的最大的正方形。那么

如果matrix[i][j]为0,则dp[i][j]必为0
如果matrix[i][j]为1,则有两种情况
- dp[i-1][j-1] > max(dp[i-1][j], dp[i][j-1]) 这种情况下，我们最大能得到min(dp[i-1][j], dp[i][j-1])+1的正方形。
- dp[i-1][j-1] < max(dp[i-1][j], dp[i][j-1]) 这种情况下，我们最大能得到dp[i-1][j-1]+1的正方形。

所以dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;

Solution 1


public static int maximalSquare(char[][] matrix) {
    //right down corner
    if (matrix.length < 1 || matrix[0].length < 1) return 0;
    int dp[][] = new int[matrix.length + 1][matrix[0].length + 1];
    int max = 0;
    for (int i = 1; i < dp.length; ++i){
        for (int j = 1; j < dp[i].length; ++j){
            if (matrix[i-1][j-1] == '0') dp[i][j] = 0;
            else dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
            max = Math.max(dp[i][j], max);
        }
    }
    return max*max;
}

Solution 2

事实上，我们并不需要mxn的矩阵来储存所有的dp元素，2xn的矩阵即可，由此我们可以将空间复杂度降低至O(n),达到理论上最优。

public static int maximalSquare(char[][] matrix) {
    //right down corner
    if (matrix.length < 1 || matrix[0].length < 1) return 0;
    int dp[][] = new int[2][matrix[0].length + 1];
    int max = 0;
    for (int i = 1; i < matrix.length + 1; ++i){
        for (int j = 1; j < matrix[0].length + 1; ++j){
            int cur = (i-1) % 2;
            int prev = i % 2;
            if (matrix[i-1][j-1] == '0') dp[cur][j] = 0;
            else dp[cur][j] = Math.min(Math.min(dp[prev][j], dp[cur][j-1]), dp[prev][j-1]) + 1;
            max = Math.max(dp[cur][j], max);
        }
    }

    return max*max;
}

Solution 3

那么，时间复杂度还有没有优化的空间呢？好像没有了，但是我的代码只能击败5%的人，为什么呢？

LeetCode 题解-47. Permutation II

Thu, 31 Oct 2019 13:42:12 GMT

对Leetcode 47. Permutation II 题目的求解。

Problem Description

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

Example

Example 1

Input: [1,1,2]
Output:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

Analysis

由题意可知，这道题是一道排列题，而且题目要求返回所有的符合的排列结果，这给我们的求解带来了很大的难度。题意很简单，就是将若干个数字的全部排列返回，并剔除重复的元素。

我们不放回想我们自己是怎么得到一串数列的全排列的。对于n个数的序列，我们假设得到了后n-1个数的所有排列，那么我们只需要将第一个数插入到这些排列的不同的位置即可得到想要n个数的全排列。由此思路我们可以写出递归法的代码。在java具体实现的时候要注意深拷贝的问题。通过已有list复制初始化并不能另开辟空间。

Solution

    public static List<List<Integer> > permuteUnique(int[] nums) {
        return my(nums, 0)；
    }
    public static List<List<Integer> > my(int [] nums, int s){
        List<List<Integer>> newres = new ArrayList<List<Integer>>  ();
        if (s >= nums.length) return newres;
        else if (s == nums.length - 1){
            List<Integer> a = new ArrayList<Integer>();
            a.add(nums[s]);
            newres.add(a);
            return newres;
        }
        List<List<Integer>> res = my(nums, s+1);
        // create new permutation
        Iterator<List<Integer>> iter = res.iterator();
        while (iter.hasNext()){
            List<Integer> l = iter.next();
            for (int i = 0; i <= l.size(); ++i){
                List<Integer> tmp = new ArrayList<Integer>();
                for (int j : l){
                    tmp.add(j);
                }
                tmp.add(i, nums[s]);
                if (newres.contains(tmp)){
                    continue;
                }
                newres.add(tmp);
            }
            iter.remove();
        }
        return newres;
    }

Optimized Solution

回溯法回溯法

LeetCode 题解-104. maximum depth of binary tree

Mon, 28 Oct 2019 08:20:09 GMT

对Leetcode 104. maximum depth of binary tree 题目的求解。

Problem Description

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Note: A leaf is a node with no children.

Example

Example 1

Given binary tree [3,9,20,null,null,15,7], return its depth = 3.

Solution 1: Iterative solution

这道题目的描述很符合递归算法的特征，而树又是非常适合递归算法的数据结构，因此我们很容易写出两行的代码。需要注意的只有对空节点的判断。

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

想要知道树的最大深度，我们只需要进行一次遍历即可。事实上，深度优先和宽度优先的算法都适用与此题。

Solution 2

深度有限遍历。

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        Stack<TreeNode> s= new Stack<TreeNode>();
        Stack<Integer> ss= new Stack<Integer>();
        s.push(root);
        ss.push(1);
        int max = 0;
        while (!s.isEmpty()){
            TreeNode n = s.pop();
            int d = ss.pop();
            max = Math.max(d, max);
            if (n.left != null){
                s.push(n.left);
                ss.push(d+1);
            }
            if (n.right != null){
                s.push(n.right);
                ss.push(d+1);
            }
        }
        return max;
}

Solution 3

宽度优先遍历

public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        Queue<Integer> qq = new LinkedList<Integer>();
        q.add(root);
        qq.add(1);
        int max = 0;
        while (!q.isEmpty()){
            TreeNode n = q.poll();
            int d = qq.poll();
            max = Math.max(d, max);
            if (n.left != null){
                q.add(n.left);
                qq.add(d+1);
            }
            if (n.right != null){
                q.add(n.right);
                qq.add(d+1);
            }
        }
        return max;
    }

Solution 4

事实上，我们还有一种更有效的遍历求解方法，即层次遍历。

    public static int maxDepth(TreeNode root) {
        if (root == null) return 0;
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.add(root);
        int max = 0;
        while (!q.isEmpty()){
            int size = q.size();
            for (int i = 0; i < size; ++i){
                TreeNode tmp = q.poll();
                if (tmp.left != null) q.add(tmp.left);
                if (tmp.right != null) q.add(tmp.right);
            }
            max += 1;
        }
        return max;
    }

LeetCode 题解-206. Reverse Linked List

Mon, 28 Oct 2019 08:20:09 GMT

对Leetcode 206. Reverse Linked List 题目的求解。

Problem Description

Reverse a singly linked list.

A linked list can be reversed either iteratively or recursively. Could you implement both?

Example

Example 1

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

Analysis

这道题的核心其实是指针的交换。方便起见，我们引入多余的head指针，指向第一个node。迭代实现和递归实现如下。

Iterative Solution

class Solution {
    ListNode zero = new ListNode(0);
    zero.next = head;
    ListNode tmp = new ListNode(0);
    while (head != null){
        tmp = head.next;
        if (tmp == null) break;
        head.next = head.next.next;
        tmp.next = zero.next;
        zero.next = tmp;
    }
    return zero.next;
}

Recursive Solution

递归方法的核心是先reverse剩余的n-1个指针，再将第一个指针接到最后。

class Solution {
    public static ListNode reverseList(ListNode head) {
        if (head == null) return head;
        ListNode tail = head;
        while (tail.next != null){
            tail = tail.next;
        }
        myreverse(head, tail);
        head.next = null;
        return tail;
    }
    public static void myreverse(ListNode head, ListNode tail){
        if (head == tail){
            return ;
        }
        myreverse(head.next, tail);
        head.next.next = head;
    }
}

LeetCode 题解-26. Remove duplicates from sorted array

Mon, 28 Oct 2019 08:20:09 GMT

对Leetcode 26. Remove duplicates from sorted array 题目的求解。

Problem Description

Given a sorted array nums, remove the duplicates in-place such that each element appear only once 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

Example 1

Given nums = [1,1,2], Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
It doesn't matter what you leave beyond the returned length.

Example 2

Given nums = [0,0,1,1,1,2,2,3,3,4],

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

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

Analysis

这道题目标签是easy，但是还是很巧妙的。由于题目要求我们只能使用O(1)的额外空间，所以我们不能新开数组。再由题意可知，我们只需要保证数组前半段的正确性，不用考虑后半段的内容，所以我们可以将数组后半段的空间利用起来。由于数组已经被排好序了，所以我们可以预见数组将会符合这样的格式：A(+)…B(+)。一个简单的想法是，对于重复出现的元素，只保留一个，将剩下的用后续元素覆盖掉。

具体实现方法即为快慢指针法。我们让慢指针p1指向去掉重复元素序列的最后一个元素，让快指针p2指向下一个要加入序列的元素。

初始时p1和p2都指向起始元素。
如果p1和p2指向的元素相同，保持p1不动，p2指向下一个元素。所以p2最终会指向大于第一个大于p1的元素。
如果p1和p2指向的元素不同，我们将p2处的元素swap到p1+1的位置。

Solution

class Solution {
        public static int removeDuplicates(int[] nums) {
        int point1 = 0;
        int point2 = 0;
        int tmp;
        // find the number point2 greater than point1,
        // and put it at point1+1
        if (nums.length <= 1){
            return nums.length;
        }
        while (point2 < nums.length){
            if (nums[point1] == nums[point2]){
                point2 += 1;
            }
            else {
                point1 += 1;
                point2 += 1;
                //swap point1 with point2-1
                tmp = nums[point1];
                nums[point1] = nums[point2-1];
                nums[point2-1] = tmp;
            }
        }
        return point1 + 1;
    }
}

Another Solution

下面这种带有loop的算法起始是快慢指针的一种变形了，其本质是相同的。

class Solution {
    public static boolean removeDuplicates(String s) {
        if (nums.length <= 1){
            return nums.length;
        }
        int cur = 1;
        for (int i = 1; i < nums.length; ++i){
            if (nums[i] > nums[cur]){
                nums[cur++] = nums[i];
            }
        }
        return cur;
    }
}

LeetCode 题解-25. Reverse Nodes in k-Group

Mon, 28 Oct 2019 08:20:09 GMT

对Leetcode 25. Reverse Nodes in k-Group 题目的求解。

Problem 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.

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

Note

Only constant extra memory is allowed.
You may not alter the values in the list's nodes, only nodes itself may be changed.

Analysis

这道题和206题一样，也是一道链表题目，核心是指针的交换操作。关键点总结如下

在链表最前端设置zero节点。
每次选中k个节点，不停地将cur的next节点挪到start的后面

事实上，代码还可以更简练，通过recursive的方法。事实上，代码还可以更简练，通过recursive的方法。

Solution

class Solution {
    public static ListNode reverseKGroup(ListNode head, int k) {
        ListNode zero = new ListNode(0);
        zero.next = head;
        ListNode start = zero;
        ListNode tail = zero;
        while (true){
            for (int i = 0; i < k ; ++i){
                tail = tail.next;
                if (tail == null) break;
            }
            if (tail == null) break;
            start = reverseK(start, k);
            tail = start;
        }
        return zero.next;
    }
    public static ListNode reverseK(ListNode start, int k){
        ListNode cur = start.next;
        for (int i = 0; i < k - 1; ++i){
            ListNode tmp = cur.next.next;
            cur.next.next = start.next;
            start.next = cur.next;
            cur.next =  tmp;
        }

        return cur;
    }
}

LeetCode 题解-198. House Robber

Thu, 24 Oct 2019 11:47:04 GMT

对Leetcode 198. House Robber 题目的求解。

Problem Description

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

Example

Example 1

Input: [1,2,3,1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
             Total amount you can rob = 1 + 3 = 4.

Example 2

Input: [2,7,9,3,1]
Output: 12
Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
             Total amount you can rob = 2 + 9 + 1 = 12.

Analysis

这道题是一道比较简单的动态规划问题。因为所有的动态规划问题的解决都基于局部最优的推广，在这个问题中，我们想要在不违反约束的情况下拿到n个house最多的现金，所以我们考虑，如果我们已经有前n-1个房子的最优解，这个时候只需要考虑抢不抢第n的房子就行了。根据题目给的约束我们可以得到 \begin{equation} dp[n] = Max(dp[n-1], dp[n-2] + a[n]) \end{equation} 其中，dp[n]代表前n个房子最多的钱，a[n]表示第n的房子的现金。在实现的时候，为了方便计算，我们将dp[0],dp[1]均设置为0，dp[n]对应低n-2个房子。

Solution

class Solution {
class Solution {
    public static int rob(int[] nums) {
        if (nums.length == 0) return 0;
        if (nums.length == 1) return nums[0];
        int dp[] = new int [nums.length + 1];
        dp[1] = nums[0];
        for (int i = 2; i < nums.length + 1; ++i){
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i-1]);
        }
        return Math.max(dp[nums.length], dp[nums.length - 1]);
    }
}

Optimized Solution

仔细观察发现，空间复杂度还有优化的空间，因为我们用到的数组其实每次迭代只需要2个元素。

class Solution {
    public static int  rob(int [] nums) {
        if (nums.length == 0) return 0;
            if (nums.length == 1) return nums[0];
            int a = 0, b = 0;
            int tmp;
            for (int i = 0; i < nums.length; ++i){
                tmp = Math.max(b, a + nums[i]);
                a = b;
                b = tmp;
            }
            return Math.max(a,b);
    }
}

LeetCode 题解-20. Valid Parentheses

Thu, 24 Oct 2019 10:01:32 GMT

对Leetcode 20. Valid Parentheses 题目的求解。

Problem Description

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order. Note that an empty string is also considered valid.

Example

Example 1

Input: "()"
Output: true

Example 2

Input: "()[]{}"
Output: true

Example 3

Input: "(]"
Output: false

Example 3

Input: "([)]"
Output: false

Analysis

这道题比较简单，只需要使用栈这种数据结构就可以轻松解决。遇到左括号，我们push进栈，遇到右括号，如果此时栈为空或者栈顶不是对应的左括号，我们即可判断匹配失败。如果是对应的左括号，那么pop出栈顶。然而我发现使用java自带的栈的代码只能在leetcode上超过60%的时间复杂度，说明我们代码还有提升空间。进一步考虑使用数组来代替java数据结构，我们只需要创建一个足够大的数组（不需要考虑扩张以及banlance factor），并且记录栈顶的位置即可。

更进一步的观察我们发现，由于需要考虑三种不同的括号，我们不得不对三个括号的匹配进行列举，使得代码冗长。如果我们在push进栈时将我们期待的右括号push进去，那么我们在后续匹配时就不用遍历三种可能的情况，而是直接比较当前括号和栈顶括号是否相同即可。

Solution

class Solution {
    public static boolean isValid(String s) {
        if (s.length() == 0) return true;
        if (s.length() % 2 == 1) return false;
        Stack<Integer> st = new Stack<Integer>();
        for (int i = 0; i < s.length(); ++i){
            if (s.charAt(i) == '('){
                st.push(0);
            }
            else if(s.charAt(i) == '{'){
                st.push(2);
            }
            else if (s.charAt(i) == '['){
                st.push(4);
            }
            else if (s.charAt(i) == ')'){
                if (! st.isEmpty() && st.peek() == 0){
                    st.pop();
                }
                else return false;
            }
            else if (s.charAt(i) == '}'){
                if (! st.isEmpty() && st.peek() == 2){
                    st.pop();
                }
                else return false;
            }
            else {
                if (! st.isEmpty() && st.peek() == 4){
                    st.pop();
                }
                else return false；
            }
        }
        return st.isEmpty();
    }
}

Optimized Solution

class Solution {
    public static boolean isValid(String s) {
        if (s.length() == 0) return true;
        if (s.length() % 2 == 1) return false;
        //Stack<Character> st = new Stack<Character>();
        char arr[] = new char[s.length()];
        int ind = -1;
        // store what we expected
        for (int i = 0; i < s.length(); ++i){
            if (s.charAt(i) == '('){
                arr[++ind] = ')';
            }
            else if (s.charAt(i) == '{'){
                arr[++ind] = '}';
            }
            else if (s.charAt(i) == '['){
                arr[++ind] = ']';
            }
            else if (ind >= 0 && arr[ind] == s.charAt(i)){
                ind --;
            }
            else {
                return false;
            }
        }
        return ind == -1;
    }
}

LeetCode 题解-3. Longest Substring Without Repeating Characters

Wed, 23 Oct 2019 09:01:45 GMT

对Leetcode 3. Longest Substring Without Repeating Characters 题目的求解。

Problem Description

Given a string, find the length of the longest substring without repeating characters.

Example

Example 1

Input: "abcabcbb"
Output: 3 
Explanation: The answer is "abc", with the length of 3.

Example 2

Input: "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3

Input: "pwwkew"
Output: 3
Explanation: 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.

Analysis

这道题很明显是一道Two-point的题目。一个很直观的想法就是维护一个sliding-window，从头到尾扫过去，记录所有可能的结果里最长的那个子串。基于这种思想，我们可以得到时间复杂度为$\Theta(n)$，空间复杂度为$O(min(m,n))$。时间复杂度很直观，我们只需要遍历一次；空间复杂度即为我们存储哈希表和sliding-window的空间。分析可知，哈希表的大小最多为字符集的大小或string的长度，所以，我们取两者最小。

事实上，基于滑动窗口的算法可以有两种不同的具体实现，如下代码所示。两种方案的不同主要集中在哈希表key-value pair的设计的不同。在第一种方案里，我们将字符作为key，将字符在当前窗口里出现的次数作为value，这样，我们可以通过value是否为0来确定该字符是否已经出现过。在第二种方案里，我们将该字符最近一次出现的位置作为value。两种方案的复杂度相同，但是在submmit的时候结果不同：第一种方案的耗时更少一点。至于具体原因，我猜测是因为在第一种方案里，我们在遇到重复字符时手动去更新哈希表所带来的时间消耗小于在第二种方案里不不更新滑动窗口缩水对哈希表的影响所带来for 循环次数的增加。

Solution No.1

    public static int lengthOfLongestSubstring(String s) {
        Map<Character, Integer> flag = new HashMap<Character, Integer>();
        if (s.length() <= 1) return s.length();
        int a=0,b=0;
        int max = 0;
        while (a <= b && b < s.length()){
            //System.out.printf("%d %d\n",b,  flag.get(s.charAt(b)));
            if (flag.getOrDefault(s.charAt(b), 0) == 0){
                flag.put(s.charAt(b), 1);
            }
            else {
                // pop out from front
                while (s.charAt(a) != s.charAt(b) && a < b){
                    flag.put(s.charAt(a), 0);
                    a+=1;
                }
                a++;
            }
            //System.out.printf("%d %d\n", a,b);
            max = Math.max(max, b - a + 1);
            b += 1;
        }
        return max;
    }

Solution No.2

在solution 2中需要注意的是i = Math.max(i, flag.get(s.charAt(j)) + 1);这句代码使得我们不用去因为滑动窗口左端pointer向左移动而删除字符而对哈希表进行更新，例如可以考虑tmsmfdut。假设我们现在j = s.length()-1，i= 2，直接取计算map.get(s.charAt(j))+1会给我们带来错误的结果，因为我们计算了两个t。所以通过取i和flag.get(s.charAt(j)) + 1两者中的最大值，我们可以确保答案是有效的。

     public static int lengthOfLongestSubstring(String s) {
        Map<Character, Integer> flag = new HashMap<Character, Integer>();
        if (s.length() <= 1) return s.length();
        int res = 0;
        for (int i = 0, j = 0; j < s.length(); ++j){
            if (flag.containsKey(s.charAt(j))){
                i = Math.max(i, flag.get(s.charAt(j)) + 1);
                //ensure the current window
            }
            flag.put(s.charAt(j), j);
            res = Math.max(res, j - i + 1);
        }
        return res;
    }

LeetCode 题解-1.two sum

Sun, 20 Oct 2019 08:31:01 GMT

对Leetcode 1. two sum 题目的求解。

Problem 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.

Example

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Solution

这道题题意很明确，即从一个数组中找出两个数，满足其和为target的要求，将这两个数的下标以数组的形式返回。首先，考虑brute-force穷举的方法，时间复杂度为 $\Theta(n^2)$，空间复杂度为$\Theta(1)$.

其次，考虑时间复杂度更低的方案。既然要找出两个数，我们不妨先确定一个数$a$，如果数组中存在$target-a$，那么我们就找到了答案。如果不行的话，我们再考虑其他数。至于如果确定数组包含某个数，我们考虑使用哈希表，来实现线性查询时间。在具体实现中，我们需要对数组进行两次遍历，第一次建立哈希表，第二次进行查询。需要注意，我们通过将数组元素的index作为value存入到hashmap中，以避免第二次遍历的时候出现自己加自己的情况。这种算法的时间复杂度为$\Theta(n)$，空间复杂度为$\Theta(n)$.

Code

class Solution {
    public static int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> m = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i){
            m.put(nums[i], i);
        }
        for (int i = 0; i < nums.length; ++i){
           if (m.get(target - nums[i]) != null && m.get(target - nums[i]) != i){
               return new int [] {Math.min(i, m.get(target - nums[i])),
                                Math.max(i, m.get(target - nums[i]))};
           }
        }
        return new int [] {0,0};
    }
}

Improved Solution

事实上，我们只需要一次遍历就可以解决问题。如代码所示，我们在遍历中首先确定查询当前元素的互补元素是否存在，如果存在的话，直接返回结果。然后在将当前元素加入哈希表，这样就可以避免将同一个元素考虑两次。

Improved Code

class Solution {
    public static int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> m = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i){
            if (m.containsKey(target - nums[i])){
               return new int [] {Math.min(i, m.get(target - nums[i])),
                                Math.max(i, m.get(target - nums[i]))};
            }
            m.put(nums[i], i);
        }
        return new int [] {0,0};
    }

Comments

这个问题其实也可以转换成 Two Pointer 来求解，只不过需要先排序，找到两个元素之后还需要在原始数组中找到对应的下标。

LeetCode 题解-2.add two numbers

Sun, 20 Oct 2019 04:11:32 GMT

对Leetcode 2. two sum 题目的求解。

Problem 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.

Example

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

Solution

就像用链表实现大整数运算一样，算法没有什么可将的，就是要注意边界条件

考虑两个n位数加起来为n+1位数的情况
考虑0+一个数的情况
考虑对齐相加进位的实现。

Code

class Solution {
    
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode res = new ListNode(0);
        ListNode tmp = res;
        int last = 0;
        while (l1 != null && l2 != null){
            tmp.next = new ListNode((l1.val + l2.val + last)%10);
            last = (l1.val + l2.val +last) / 10;
            l1 = l1.next;
            l2 = l2.next;
            tmp = tmp.next;
        }
        ListNode temp = null;
        if (l1 != null){
            temp = l1;
        }
        if (l2 != null){
            temp = l2;
        }
        while (temp != null){
            tmp.next = new ListNode((temp.val + last)%10);
            last = (temp.val +last) / 10;
            temp = temp.next;
            tmp = tmp.next;
        }
        if (last > 0){
            tmp.next = new ListNode(last);
        }
        return res.next;
    }
}

Cuda10 installation on Ubuntu 16.04

Fri, 18 Oct 2019 08:04:36 GMT

由于项目要用到的代码对tensorflow版本要求较高，我需要将机器上的tensorflow1.0+cuda-8.0升级到tensorflow2.0+cuda-10.0。然而在重装了cuda10.0+cudnn7.5之后，运行nvidia-smi显示

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. Make sure that the latest NVIDIA driver is installed and running.

我理解为是nvidia driver的版本不够高，所以直接从nvidia-384升级到nvidia-430,并重启了计算机。结果就发现重启之后电脑黑屏了。最终费了好大的周折将这个问题解决，现在将具体过程记录如下。

解决黑屏问题。

首先重启之后屏幕一直处于黑屏状态，我怀疑是nvidia显卡驱动没有正常工作，于是将显示器的输入口接到主板的集显的输出口。终于显示器上出现了低分辨率的变形的输出。为了避免忍受这种痛苦，ctrl+alt+f1进入tty1的shell中。既然显卡驱动出现了问题，我们考虑彻底卸载nvidia驱动和cuda以重新开始。
```
sudo apt purge nvidia*
sudo /usr/cuda/bin/uninstall_cuda_10.0.pl
```
卸载完成之后重启，遇到了Ubuntu重复登录界面的问题。即便是输入了正确的用户名和口令，也会继续重复登录。
解决重登录问题。

在上网搜索了上多解决方案之后，大多数人都归因与nouveau和opengl的一些异常。遵照前人的方法，首先，禁用掉nouveau驱动。
```
sudo vim etc/modprobe.d/blacklist
#在该文件中加入下面两行代码
blacklist nouveau
options nouveau modeset=0
```
重新安装nvidia驱动。需要前往nvidia官网下载自己系统对应的可用驱动，建议选择run file。
```
#首先关掉x-window manager lightdm
sudo service lightdm stop
#安装驱动
sudo **/NVIDIA-Linux-x86_64-VERSION.run –no-x-check –no-nouveau-check –no-opengl-files
sudo reboot
```
这里需要注意，后面的三个参数很重要，分别指定关闭x-window 服务，禁用nouveau，不安装opengl文件。重启之后，终于可以登入桌面。接着将显示器的接口插在显卡输出口上，同样也出现了桌面。但是新的问题也出现了：Ubuntu桌面坏了，任务栏消失了，快捷键失灵。
解决桌面问题。

初步确定为是桌面程序出现故障，所以选择最简单直接的办法：重装。
```
sudo apt purge ubuntu-desktop
sudo apt autoremove
sudo apt install ubuntu-desktop
#这里可以选择不同的桌面，例如gnome，unity
sudo apt install unity
sudo reboot
```
重启之后在登录界面选择ubuntu桌面，即可进入熟悉的桌面。
解决显卡输出帧数降低，显示卡顿的问题。

新的问题接踵而至。由于驱动版本过高(430)，我的显卡不太支持，图形化界面掉帧严重，特别是观看网页视频的时候目测只有30-40帧。于是回滚到较低版本的nvidia驱动，这里我选择了418。除了从官方网站下载驱动之外，这里介绍另外一种方案。
- software and updates -> additional drivers -> 选择418驱动 -> apply changes -> reboot 终于，我们显示器画面丝滑流畅！