Posted Updated LeetCode / Medium2 minutes read (About 252 words)

535. Encode and Decode TinyURL

Note: This is a companion problem to the System Design problem: Design TinyURL.
TinyURL is a URL shortening service where you enter a URL such as https://leetcode.com/problems/design-tinyurl and it returns a short URL such as http://tinyurl.com/4e9iAk. Design a class to encode a URL and decode a tiny URL.

There is no restriction on how your encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL and the tiny URL can be decoded to the original URL.

Implement the Solution class:

  • Solution() Initializes the object of the system.
  • String encode(String longUrl) Returns a tiny URL for the given longUrl.
  • String decode(String shortUrl) Returns the original long URL for the given shortUrl. It is guaranteed that the given shortUrl was encoded by the same object.

计算传入连接的哈希值。将其作为key放入map中。
解码时将url转换为key，取出map中的value。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Codec {
    HashMap<Integer, String> map = new HashMap<>();
    
    // Encodes a URL to a shortened URL.
    public String encode(String longUrl) {
        int key = longUrl.hashCode();
        map.put(key, longUrl);
        return Integer.toString(key);
    }

    // Decodes a shortened URL to its original URL.
    public String decode(String shortUrl) {
        return map.get(Integer.parseInt(shortUrl));
    }
}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.decode(codec.encode(url));
Posted Updated LeetCode / Medium / 复习3 minutes read (About 519 words)

1091. Shortest Path in Binary Matrix

Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.

A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:

All the visited cells of the path are 0.
All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner).
The length of a clear path is the number of visited cells of this path.

由于不能重复搜索，且需要在搜索时将搜索过的位置改变，因此需要采用BFS逐一层级的搜索。
逐层级搜索并记录层级。最后返回层级+1即可。
（还有更快的优化算法A*）

整体没有改变太多，基本还是方法二那种。启发式函数改为切比雪夫距离距离。
距离计算方法有很多，常用启发式函数有这几种。选择合适的启发式函数有利于速度的提升。这题可以用好几种启发式函数，初学都可以试着都写一下。

曼哈顿距离（Manhattan Distance）
一般只能在四个方向上移动时用（右、左、上、下）

对角线距离（Diagonal Distance）：
当我们只允许向八个方向移动时用（国际象棋中的王移动方式那种）

欧几里得距离（Euclidean Distance）：
不受限制，允许向任何方向移动时。

切比雪夫距离（Chebyshev Distance）：
可参考：[https://leetcode-cn.com/problems/minimum-time-visiting-all-points/solution/fang-wen-suo-you-dian-de-zui-xiao-shi-jian-by-le-2/](LeetCode 1266)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Solution {
    public int shortestPathBinaryMatrix(int[][] grid) {
        int n = grid[0].length;
        int m = grid.length;
        
        Queue<Integer> q = new LinkedList<>();
        int count = 0;
        q.add(0);
        int size = q.size();
        
        while(!q.isEmpty()){
            for(int k = 0; k < size; k++){
                int curr = q.poll();
                int i = curr / n;
                int j = curr % n;

                if(grid[i][j] ==1) continue;                
                if(i == m-1 && j == n-1 && grid[i][j] == 0) return count+1;
            
                if(grid[i][j] == 0){
                    grid[i][j] = 1;
                    if(i+1<n && j+1<n) q.add((i+1) * n + (j+1));
                    if(i+1<n && j-1>=0) q.add((i+1) * n + (j-1));
                    if(i+1<n) q.add((i+1) * n + j);
                    if(i-1>=0 && j-1>=0) q.add((i-1) * n + (j-1));
                    if(i-1>=0 && j+1<n) q.add((i-1) * n + (j+1));
                    if(j+1<n) q.add(i * n + (j+1));
                    if(j-1>=0) q.add(i * n + (j-1));
                    if(i-1>=0) q.add((i-1) * n + j);
                }
            }
            size = q.size();
            count++;
        }
        return -1;
    }
}
Posted Updated LeetCode / Easy2 minutes read (About 256 words)

572. Subtree of Another Tree

Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.

A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node’s descendants. The tree tree could also be considered as a subtree of itself.

帮助方法isEqual，DFS搜索判断两个节点的子节点是否完全相同。
DFS搜索，如果两个根节点的值相等则返回，且调用isEqual方法，如果子节点都相同则返回。

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
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        return dfs(root, subRoot) != null;
    }
    
    private TreeNode dfs(TreeNode root, TreeNode subRoot){
        if(root == null) return null;
        if(root.val == subRoot.val && isEqual(root, subRoot)) return root;
        if(dfs(root.left, subRoot) != null ) return dfs(root.left, subRoot);
        else return dfs(root.right, subRoot);
    }
    
    private boolean isEqual(TreeNode root, TreeNode subRoot){
        if(root == null || subRoot == null) return root == subRoot;
        if(root.val != subRoot.val) return false;
        return isEqual(root.left, subRoot.left) && isEqual(root.right, subRoot.right);
    }
}
Posted Updated LeetCode / Mediuma minute read (About 213 words)

117. Populating Next Pointers in Each Node II

Question

Given a binary tree

1
2
3
4
5
6
struct Node {
 int val;
 Node *left;
 Node *right;
 Node *next;
}

Populate each next pointer to point to its next right node. If > there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Solution

BFS搜索，从右至左将每层节点放入队列。
用一个size记录该层级放入节点的数量，每次循环将size-1，当size归零时放入新一层级的节点。

Code

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
/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root == null) return root;
        
        Queue<Node> q = new LinkedList();
        q.add(root);
        
        while(!q.isEmpty()){
            int size = q.size();
            Node next = null;
            while(size > 0){
                size--;
                Node curr = q.poll();
                curr.next = next;
                next = curr;
                if(curr.right != null) q.add(curr.right);
                if(curr.left != null) q.add(curr.left);
            }
        }
        return root;
    }
}
Posted Updated LeetCode / Mediuma minute read (About 219 words)

763. Partition Labels

You are given a string s. We want to partition the string into as many parts as possible so that each letter appears in at most one part.

Note that the partition is done so that after concatenating all the parts in order, the resultant string should be s.

Return a list of integers representing the size of these parts.

将英文字母出现的首尾作为intervals看待。
根据字符创建数组并填入左右的index。
根据左侧index排序数组。

从左至右，如果intervals有交集，则合并。
否则在答案中添加当前interval的长度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Solution {
    public List<Integer> partitionLabels(String s) {
        int[][] alphabet = new int[26][2];
        int head = s.charAt(0) - 'a';
        for(int i = 0; i < s.length(); i++){
            int index = s.charAt(i) - 'a';
            if(head != index && alphabet[index][0] == 0) alphabet[index][0] = i;
            alphabet[index][1] = i;
        }
        
        Arrays.sort(alphabet, (a,b) -> a[0] - b[0]);
        
        List<Integer> ans = new ArrayList();
        int[] hold = alphabet[0];
        for(int i = 1; i < alphabet.length; i++){
            if(alphabet[i][0] <= hold[1]){
                hold[1] = Math.max(hold[1], alphabet[i][1]);
            }
            else{
                ans.add(hold[1]-hold[0]+1);
                hold = alphabet[i];
            }
        }
        ans.add(hold[1]-hold[0]+1);
        return ans;
        
    }
}
Follow

Recents

Archives

Links

×