Leetcode算法解析51-100

<center>#51 N-Queens</center>

  • link
  • 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.
    • avator
  • Input: 4
  • Output: [[".Q..", // Solution 1 "...Q", "Q...", "..Q."], ["..Q.", // Solution 2 "Q...", "...Q", ".Q.."]]
  • Solution:
    • dfs寻找组合的问题， 注意保存每一点的坐标信息
    • 规则是不能在同一行或者同一列或者对角线上
    • 可以通过二元组存坐标信息，也可以直接通过数组，数组索引做x， 值做y
  • Code: 
    # code block
public List<List<String>> solveNQueens(int n) {
    List<List<String>> result = new ArrayList<>();
    if (n <= 0) {
        return result;
    }
    dfsHelper(n, 0, new ArrayList<Integer>(), result);
    return result;
}

private void dfsHelper(int n, int x, List<Integer> state, List<List<String>> result) {
    if (n == x) {
        generateSolution(state, n, result);
        return;
    }
    for (int i = 0; i < n; i++) {
        if (valid(x, i, state)) {
            state.add(i);
            dfsHelper(n, x + 1, state, result);
            state.remove(state.size() - 1);
        }
    }
}

private boolean valid(int x, int y, List<Integer> state) {
    for (int i = 0; i < state.size(); i++) {
        if (y == state.get(i)) {
            return false;
        }
        if (Math.abs(y - state.get(i)) == Math.abs(x - i)) {
            return false;
        }
    }
    return true;
}

private void generateSolution(List<Integer> state, int n, List<List<String>> result) {
    List<String> solution = new ArrayList<>();
    for (Integer x : state) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < x; i++) {
            sb.append(".");
        }
        sb.append("Q");
        for (int i = x + 1; i < n; i++) {
            sb.append(".");
        }
        solution.add(sb.toString());
    }
    result.add(solution);
}

<center>#52 N-Queens II</center>

  • link
  • Description:
    • Follow up for N-Queens problem.
    • Now, instead outputting board configurations, return the total number of distinct solutions.
  • Input: 5
  • Output: 10
  • Solution:
    • N Queens 的follow up， 用一个全局的计数器计算组合就行
  • Code: 
    # code block
class Solution {
    public int totalNQueens(int n) {
        if (n <= 0) {
            return 0;
        }
        dfsHelper(n, 0, new ArrayList<Integer>());
        return result;
    }

    private void dfsHelper(int n, int x, List<Integer> state) {
        if (n == x) {
            result++;
            return;
        }
        for (int i = 0; i < n; i++) {
            if (valid(x, i, state)) {
                state.add(i);
                dfsHelper(n, x + 1, state);
                state.remove(state.size() - 1);
            }
        }
    }

    private boolean valid(int x, int y, List<Integer> state) {
        for (int i = 0; i < state.size(); i++) {
            if (y == state.get(i)) {
                return false;
            }
            if (Math.abs(y - state.get(i)) == Math.abs(x - i)) {
                return false;
            }
        }
        return true;
    }

    private int result = 0;
}

<center>#53 Maximum Subarray</center>

  • link

  • Description:

    • Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

  • Input: [-2,1,-3,4,-1,2,1,-5,4]

  • Output: 6

  • Assumptions:

    • containing at least one number

  • Solution:

    • 使用preSum的典型题。Sum(i, j) = Sum(0, j) - Sum(0, i - 1);
    • 边界情况的处理， max 初始值设为最小int肯定会被更新， preMin设为0确保了最少包含一个值，刻意应付全部都是负数的corner case。

  • Code:

    # code block
public int maxSubArray(int[] nums) {
    if (nums == null || nums.length == 0) {
        return -1;
    }
    int max = Integer.MIN_VALUE;
    int preSum = 0;
    int preMin = 0;
    for (int i = 0; i < nums.length; i++) {
        preSum += nums[i];
        max = Math.max(max, preSum - preMin);
        preMin = Math.min(preMin, preSum);
    }
    return max;
}

  • Time Complexity: O(n)

  • Space Complexity: O(1)

<center>#55 Jump Game</center>

  • link
  • Description:
    • 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.
  • Input: [2,3,1,1,4]
  • Output: true
  • Assumptions:
    • non-negative integers
  • Solution:
    • 贪心法。 每到达一个能到达的点，都去刷新所能到的最远距离，最后比较能到的最远距离和最后一个元素的索引。
  • Code: 
    # code block
public boolean canJump(int[] nums) {
    if (nums == null || nums.length == 0) {
        return true;
    }
    int reach = 0;
    for (int i = 0; i < nums.length; i++) {
        if (i <= reach) {
            reach = Math.max(reach, i + nums[i]);
        }
    }
    return reach >= nums.length - 1 ? true : false;
}
  • Time Complexity: O(n)
  • Space Complexity: O(1)

<center>#58 Length of Last Word</center>

  • link
  • Description:
    • Given a string s consists of upper/lower-case alphabets and empty space characters ' ', return the length of last word in the string.
  • Input: s = "Hello World"
  • Output: 5
  • Assumptions:
    • If the last word does not exist, return 0.
  • Solution:
    • 模拟题，注意处理boundary case
  • Code: 
    # code block
public int lengthOfLastWord(String s) {
    if (s == null || s.length() == 0) {
        return 0;
    }
    String tmp = s.trim();
    int length = 0;
    char[] tc = tmp.toCharArray();
    for (int i = tc.length - 1; i >= 0; i--) {
        if (Character.isLetter(tc[i])) {
            length++;
        } else {
            break;
        }
    }
    return length;
}
  • Time Complexity: O(n)

<center>#60 Permutation Sequence</center>

  • link
  • Description:
    • 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 (ie, for n = 3):
      "123"
  "132"
  "213"
  "231"
  "312"
  "321"
    • Given n and k, return the kth permutation sequence.
  • Input: 3, 2
  • Output: 132
  • Assumptions:
    • Given n will be between 1 and 9 inclusive.
  • Solution:
    • 暴力的解法是使用DFS遍历并计数，时间复杂度过高
    • 遇到permutation的题第一件事先把图画出来
    • 可以找到规律，每一层节点为根的树有m！个叉，根据这个可以判断每层分别是哪个数
  • Code: 
    # code block
public String getPermutation(int n, int k) {
    if (n == 1) {
        return "1";
    }
    int[] factor = new int[n + 1];
    factor[0] = 1;
    for (int i = 1; i <= n; i++) {
        factor[i] = factor[i - 1] * i;
    }
    k = (k - 1) % factor[n];
    StringBuilder sb = new StringBuilder();
    boolean[] flag = new boolean[n];
    for (int i = n - 1; i >= 0; i--) {
        int idx = k / factor[i];
        sb.append(getNth(idx, flag));
        k -= factor[i] * idx;
    }
    return sb.toString();
}

private int getNth(int idx, boolean[] flag) {
    int count = idx;
    int i = 0;
    while (i < flag.length) {
        if (flag[i]) {
            i++;
            continue;
        }
        if (count == 0) {
            flag[i] = true;
            return i + 1;
        }
        i++;
        count--;
    }
    return -1;
}
  • Time Complexity: O(n ^ 2)
  • Space Complexity: O(n)

<center>#61 Rotate List</center>

  • link
  • Description:
    • Given a list, rotate the list to the right by k places, where k is non-negative.
  • Input: 1->2->3->4->5->NULL k=2
  • Output: 4->5->1->2->3->NULL
  • Solution:
    • 注意各种corner case 的处理
  • Code: 
    # code block
public ListNode rotateRight(ListNode head, int k) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode last = head;
    int length = 1;
    while (last.next != null) {
        length++;
        last = last.next;
    }
    k = k % length;
    if (k == 0) {
        return head;
    }
    int cut = length - k;
    ListNode prev = head;
    for (int i = 0; i < cut - 1; i++) {
        prev = prev.next;
    }
    ListNode next = prev.next;
    // n1->...->prev->next->...->nLast
    // next->...->nLast->n1->...->prev
    prev.next = null;
    last.next = head;
    return next;
}
  • Time Complexity: O(n)
  • Space Complexity: O(1)

<center>#66 Plus One</center>

  • link
  • Description:
    • Given a non-negative integer represented as a non-empty array of digits, plus one to the integer.
  • Input: [9,9,9]
  • Output: [1,0,0,0]
  • Assumptions:
    • assume the integer do not contain any leading zero, except the number 0 itself.
      • The digits are stored such that the most significant digit is at the head of the list.
  • Solution:
    • 本题最重要的是考虑到各种corner case的处理。比如加完之后大于10的进位， 比如999加一会答案位数会发生改变。
  • Code: 
    # code block
public int[] plusOne(int[] digits) {
    if (digits == null || digits.length == 0) {
        return digits;
    }
    int carrier = 1;
    for (int i = digits.length - 1; i >= 0; i--) {
        int val = digits[i] + carrier;
        digits[i] = val % 10;
        carrier = val / 10;
    }
    if (carrier == 0) {
        return digits;
    }
    // one more digit than digits array
    int[] result = new int[digits.length + 1];
    result[0] = 1;
    for (int i = 0; i < digits.length; i++) {
        result[i + 1] = digits[i];
    }
    return result;
}
  • Time Complexity: O(n)
  • Space Complexity: O(1)

<center>#67 Add Binary</center>

  • link
  • Description:
    • Given two binary strings, return their sum (also a binary string).
  • Input: a = "11" b = "1"
  • Output: "100"
  • Solution:
    • 注意边界条件判断
    • 思路很简单，注意进位不要忽略
  • Code: 
    # code block
public String addBinary(String a, String b) {
    if (a == null || a.length() == 0) {
        return b;
    }
    if (b == null || b.length() == 0) {
        return a;
    }
    StringBuilder sb = new StringBuilder();
    int idx_a = a.length() - 1, idx_b = b.length() - 1;
    int carrier = 0;
    while (idx_a >= 0 && idx_b >= 0) {
        int val = a.charAt(idx_a) - '0' + b.charAt(idx_b) - '0' + carrier;
        sb.append(val % 2);
        carrier = val / 2;
        idx_a--;
        idx_b--;
    }
    while (idx_a >= 0) {
        int val = a.charAt(idx_a) - '0' + carrier;
        sb.append(val % 2);
        carrier = val / 2;
        idx_a--;
    }
    while (idx_b >= 0) {
        int val = b.charAt(idx_b) - '0' + carrier;
        sb.append(val % 2);
        carrier = val / 2;
        idx_b--;
    }
    if (carrier != 0) {
        sb.append(carrier);
    }
    return sb.reverse().toString();
}
  • Time Complexity: O(m + n)
  • Space Complexity: O(1)

<center>#69 Sqrt(x)</center>

  • link
  • Description:
    • Implement int sqrt(int x).
  • Input: 2147483647
  • Output: 46340
  • Solution:
    • 这是一道二分法求答案的题，二分的范围不是很直接
    • 这题最重要的是考虑了overflow的情况
  • Code: 
    # code block
public int mySqrt(int x) {
    if (x <= 0) {
        return 0;
    }
    long start = 1, end = x;
    while (start < end - 1) {
        long mid = start + (end - start) / 2;
        if (mid * mid == x) {
            return (int)mid;
        } else if (mid * mid > x) {
            end = mid;
        } else {
            start = mid;
        }
    }
    if (end * end <= x) {
        return (int)end;
    }
    return (int)start;
}
  • Time Complexity: O(lg n)
  • Space Complexity: O(1)

<center>#70 Climbing Stairs</center>

  • link
  • Description:
    • 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?
    • Given n will be a positive integer.
  • Input: 6
  • Output: 13
  • Solution:
    • 动态规划的入门题
    • 暴力解法使用搜索，会有大量重复计算
    • 每一步只与前两步有关，所以初始化一二步，之后不断更新前两步的值
  • Code: 
    # code block
public int climbStairs(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    int n_prev = 1;
    int n_curr = 1;
    for (int i = 2; i <= n; i++) {
        int n_next = n_prev + n_curr;
        n_prev = n_curr;
        n_curr = n_next;
    }
    return n_curr;
}
  • Time Complexity: O(n)
  • Space Complexity: O(1)

<center>#75 Sort Colors</center>

  • link

  • Description:

    • Given an array with n objects colored red, white or blue, sort them 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

  • Input: [1,2,2,1,1,0]

  • Output:[0,1,1,1,2,2]

  • Assumptions:

    • You are not suppose to use the library's sort function for this problem.

  • Solution:

    • 典型的Partition题， 最简单的思路是先对0 和 大于 0 做一次partition， 对1和2做一次partition。这样虽然时间复杂度依然是O(n)， 但是还有一次遍历的更优方法。
    • 以下方法(Rainbow sort)中，区间[0, l）都是0， 区间（r, end]都是2. 根据该算法可以确定， [l, r)这个区间内全是1. 当跳出循环的时候i = r + 1, 可以确保[0, l) 是0, [l, i) 是1， [i, end]是2.
      因为只遍历了一次，所以时间复杂度还是O(n)， 空间复杂度O(1)。

  • Code:

    # code block
public void sortColors(int[] nums) {
    if (nums == null || nums.length == 0) {
        return;
    }
    int l = 0, r = nums.length - 1;
    int i = 0;
    while (i <= r) {
        if (nums[i] == 0) {
            swap(nums, i, l);
            l++;
            i++;
        } else if (nums[i] == 1) {
            i++;
        } else {
            swap(nums, i, r);
            r--;
        }
    }
}

private void swap(int[] nums, int a, int b) {
    int tmp = nums[a];
    nums[a] = nums[b];
    nums[b] = tmp;
}

  • Time Complexity: O(n)

  • Space Complexity: O(1)

<center>#77 Combinations</center>

  • link
  • Description:
    • Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.
  • Input: n = 4 and k = 2
  • Output: [[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],]
  • Solution:
    • 注意边界条件判断
    • combination的变形
    • 因为长度限定，所以可以剪枝优化，优化的地方用pluning注释了
  • Code: 
    # code block
public List<List<Integer>> combine(int n, int k) {
    List<List<Integer>> result = new ArrayList<>();
    if (n < 1 || k > n) {
        return result;
    }
    dfsHelper(n, k, 1, new ArrayList<Integer>(), result);
    return result;
}

private void dfsHelper(int n, int k, int start, List<Integer> state, List<List<Integer>> result) {
    if (k == 0) {
        result.add(new ArrayList<Integer>(state));
        return;
    }

    for (int i = start; i <= n - k + 1; i++) {
        state.add(i);
        dfsHelper(n, k - 1, i + 1, state, result);
        state.remove(state.size() - 1);
    }
}

<center>#78 Subsets</center>

  • link
  • Description:
    • Given a set of distinct integers, nums, return all possible subsets.
  • Input: [1,2,3]
  • Output: [[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]]
  • Assumptions:
    • The solution set must not contain duplicate subsets.
  • Solution:
    • 子集问题就是隐式图的深度优先搜索遍历。因为是distinct，所以不需要去重。
  • Code: 
    # code block
public List<List<Integer>> subsets(int[] nums) {
     List<List<Integer>> result = new ArrayList<>();
     if (nums == null || nums.length == 0) {
         result.add(new ArrayList<Integer>());
         return result;
     }
     dfsHelper(nums, 0, new ArrayList<Integer>(), result);
     return result;
 }

 private void dfsHelper(int[] nums, int start, List<Integer> state, List<List<Integer>> result) {
     result.add(new ArrayList<Integer>(state));
     for (int i = start; i < nums.length; i++) {
         state.add(nums[i]);
         dfsHelper(nums, i + 1, state, result);
         state.remove(state.size() - 1);
     }
 }
  • Time Complexity: O(2 ^ n)
  • Space Complexity: O(n)

<center>#79 Word Search</center>

  • link
  • Description:
    • 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.
  • Input: board = [
    ['A','B','C','E'],
    ['S','F','C','S'],
    ['A','D','E','E']
    ] word = "ABCCED"
  • Output: true
  • Assumptions:
  • Solution:
    • 典型的图上的搜索题，因为要搜索所有的组合， 所以推荐使用DFS， 利用回溯，只需要维持一个状态
    • 注意点
      • 图上的遍历问题可以利用dx， dy数组来优化代码
      • 把判断是否在边界内写成一个私有函数来优化代码
      • 递归的出口的选择
  • Code:
# code block
class Solution {
    public static final int[] dx = {1, 0, 0, -1};
    public static final int[] dy = {0, 1, -1, 0};
    public boolean exist(char[][] board, String word) {
        if (word == null || word.length() == 0) {
            return true;
        }
        if (board == null || board.length == 0 || board[0].length == 0) {
            return false;
        }
        int m = board.length, n = board[0].length;
        char[] wc = word.toCharArray();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                boolean[][] visited = new boolean[m][n];
                if (board[i][j] != wc[0]) {
                    continue;
                }
                if (dfsHelper(board, wc, visited, i, j, 0)) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean dfsHelper(char[][] board, char[] wc, boolean[][] visited, int x, int y, int start) {
        if (visited[x][y]) {
            return false;
        }
        if (wc[start] != board[x][y]) {
            return false;
        }
        if (start == wc.length - 1) {
            // find the word
            return true;
        }
        visited[x][y] = true;
        for (int i = 0; i < 4; i++) {
            if (valid(x + dx[i], y + dy[i], board, visited) && dfsHelper(board, wc, visited, x + dx[i], y + dy[i], start + 1)) {
                return true;
            }
        }
        visited[x][y] = false;
        return false;
    }

    private boolean valid(int x, int y, char[][] board, boolean[][] visited) {
        return x >= 0 && x < board.length && y >= 0 && y < board[0].length && !visited[x][y];
    }
}
  • Time Complexity: O(m * n)
    • DFS的时间复杂度是边的个数
  • Space Complexity: O(m ^ 2 * n ^ 2)
    • 判断是否访问过的boolean数组，worst case 可能有 n ^ 2个

<center>#80 Remove Duplicates from Sorted Array II</center>

  • link
  • Description:
    • Follow up for "Remove Duplicates":
    • What if duplicates are allowed at most twice?
  • Input: [1,1,2,2,2,3,3,3]
  • Output: [1,1,2,2,3,3]
  • Solution:
    • 去重，但是每个元素可以保留两个，实现的方法不止一种，但是要考虑到改变了数组中的值是否会对后续判断产生影响。
  • Code: 
    # code block
public int removeDuplicates(int[] nums) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    int idx = 0;
    int i = 0;
    while (i < nums.length) {
        int val = nums[i];
        int count = 0;
        while (i < nums.length && nums[i] == val) {
            i++;
            count++;
        }
        for (int j = 0; j < 2 && j < count; j++) {
            nums[idx++] = val;
        }
    }
    return idx;
}
  • Time Complexity: O(n)
  • Space Complexity: O(1)

<center>#83 Remove Duplicates from Sorted List</center>

  • link
  • Description:
    • Given a sorted linked list, delete all duplicates such that each element appear only once.
  • Input: 1->1->2
  • Output: 1->2
  • Solution:
    • 基础的链表去重题，注意指针的赋值
  • Code: 
    # code block
public ListNode deleteDuplicates(ListNode head) {
  if (head == null) {
      return head;
  }
  ListNode dummy = new ListNode(0);
  dummy.next = head;
  while (head.next != null) {
      if (head.next.val == head.val) {
          head.next = head.next.next;
      } else {
          head = head.next;
      }
  }
  return dummy.next;

}

* Time Complexity: O(n)
* Space Complexity: O(1)
### <center>#86 Partition List</center>
* [link](https://leetcode.com/problems/partition-list/description/)
* Description:
* 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.
* Input: 1->4->3->2->5->2 and x = 3
* Output: 1->2->2->4->3->5
* Solution:
* 简单链表题，注意使用dummynode和指针赋值的先后问题
* Code:

code block

public ListNode partition(ListNode head, int x) {
ListNode dummy1 = new ListNode(0);
ListNode dummy2 = new ListNode(0);
ListNode curr1 = dummy1;
ListNode curr2 = dummy2;
while (head != null) {
if (head.val < x) {
curr1.next = head;
head = head.next;
curr1 = curr1.next;
curr1.next = null;
} else {
curr2.next = head;
head = head.next;
curr2 = curr2.next;
curr2.next = null;
}
}
curr1.next = dummy2.next;
return dummy1.next;
}

* Time Complexity: O(n)
* Space Complexity: O(1)
### <center>#88 Merge Sorted Array</center>
* [link](https://leetcode.com/problems/merge-sorted-array/description/)
* Description:
* Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
* Input: [4,5,6,0,0,0] 3 [1,2,3] 3
* Output: [1,2,3,4,5,6]
* Assumptions:
* You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2. The number of elements initialized in nums1 and nums2 are m and n respectively.

* Solution:
*  用归并排序的merge方法。不适用额外空间的方法就是从尾巴开始归并， 先把大的数填进去
* Code:

code block

public void merge(int[] nums1, int m, int[] nums2, int n) {
int length = m + n;
int ptM = m - 1;
int ptN = n - 1;
int pt = length - 1;
while (pt >= 0) {
if (ptN < 0) {
//nums2 merge complete, nums1 can left as it is
break;
} else if (ptM < 0) {
nums1[pt] = nums2[ptN--];
} else if (nums1[ptM] > nums2[ptN]) {
nums1[pt] = nums1[ptM--];
} else {
nums1[pt] = nums2[ptN--];
}
pt--;
}
}

* Time Complexity: O(n)
* Space Complexity: O(1)
### <center>#90 Subsets II</center>
* [link](https://leetcode.com/problems/subsets-ii/description/)
* Description:
* Given a collection of integers that might contain duplicates, nums, return all possible subsets.
* The solution set must not contain duplicate subsets.
* Input: nums = [1,2,2]
* Output:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

* Solution:
* 先排序，去重, 去重的地方注释了remove duplicate
* 对subsets的隐式图进行遍历，记录下每一个状态
* Code:

code block

public List<List<Integer>> subsetsWithDup(int[] nums) {
List<List<Integer>> subsets = new ArrayList<>();
if (nums == null || nums.length == 0) {
subsets.add(new ArrayList<Integer>());
return subsets;
}
Arrays.sort(nums);
dfsHelper(nums, 0, new ArrayList<Integer>(), subsets);
return subsets;
}

private void dfsHelper(int[] nums, int start, List<Integer> state, List<List<Integer>> subsets) {
subsets.add(new ArrayList<Integer>(state));
for (int i = start; i < nums.length; i++) {
// remove duplicate
if (i != start && nums[i] == nums[i - 1]) {
continue;
}
state.add(nums[i]);
dfsHelper(nums, i + 1, state, subsets);
state.remove(state.size() - 1);
}
}

* Time Complexity: O(n * 2 ^ n)
* Space Complexity: O(n)
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,324评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,303评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,192评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,555评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,569评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,566评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,927评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,583评论 0赞 257
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,827评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,590评论 2赞 320
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,669评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,365评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,941评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,928评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,159评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,880评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,399评论 2赞 342

推荐阅读更多精彩内容