单词搜索 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

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

给定 word = "ABCCED", 返回 true
给定 word = "SEE", 返回 true
给定 word = "ABCB", 返回 false


提示：

board 和 word 中只包含大写和小写英文字母。
1 <= board.length <= 200
1 <= board[i].length <= 200
1 <= word.length <= 10^3

主要思路
本题本质上还是回溯算法的运用，啊啊啊啊，回溯好难啊，今天的卡点在于怎么正确的在回溯过程中设置返回值，有进步的在于整体思路还是没得问题，重点在于返回值的确定，多刷题，多看吧
技巧：利用二维偏移量数组来简化代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Solution {
    public boolean exist(char[][] board, String word) {
        if(board.length==0)
			return false;
		int l = board.length;
		int w = board[0].length;
		boolean [][] visited = new  boolean[l][w];
		for(int i = 0;i<l;i++) {
			for(int j = 0;j<w;j++) {
				if(board[i][j]==word.charAt(0)) {
					if(dfs(board, visited, i, j, word, 0))
						return true;
					
				}
			}
		}
		return false;
    }
    public static boolean dfs(char [][] board,boolean [][] visited,int i,int j,String word,int index) {
		if(index==word.length()-1)
			return board[i][j]==word.charAt(index);
        if(board[i][j]!=word.charAt(index))
			return false;
		visited[i][j] = true;
		int [][] directions = {{0,1},{0,-1},{1,0},{-1,0}};
		for(int[]com:directions) {
			int newX = i+com[0];
			int newY = j+com[1];
			if(newX>=0&&newX<board.length&&newY>=0&&newY<board[0].length&&visited[newX][newY]==false)
				if(dfs(board, visited, newX, newY, word, index+1)) {
					return true;
				}
		}
		visited[i][j] = false;
		return false;
}
}

展开全文 >>

最短回文串 

1
2
3
4
5
6
7
8
9
10
11
12
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。


示例：

输入："Let's take LeetCode contest"
输出："s'teL ekat edoCteeL tsetnoc"


提示：

在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

此题目的
学会熟练使用java中字符串中的一些操作API函数，例如本题的spilt，trim函数等，此外，String类以及字符串都不提供反转操作，但StringBuffer中有此操作，所以可以转换成StringBuffer再转成String 

1
2
3
4
5
6
7
8
9
10
11
12
class Solution {
    public String reverseWords(String s) {
        String[] strs = s.split(" ");
		 StringBuffer tem = new StringBuffer();
		 for(String str:strs) {
		    //利用库函数反转字符串
			 tem.append(new StringBuffer(str).reverse().toString());
			 tem.append(" ");
		 }
		 return tem.toString().trim();
    }
}

展开全文 >>

最短回文串 

1
2
3
4
5
6
7
8
9
10
给定一个字符串 s，你可以通过在字符串前面添加字符将其转换为回文串。找到并返回可以用这种方式转换的最短回文串。

示例1:

输入: "aacecaaa"
输出: "aaacecaaa"
示例 2:

输入: "abcd"
输出: "dcbabcd"

主要思路：
本题是KMP算法的一种运用，利用Next数组解题法宝，利用KMP求解最长回文前缀
例如abc这个字符串，前缀加上cba，由于a一个字符可以看作是回文的，所以我们删除a，只用加上cb构成cbabc这个最短的回文字符串，再比如cbjbcb这个字符串，先反转得到bcbjbc，由于cbjbc本身就是回文的，反转后还是本身，所以这个删除两个字符串重叠的部分，得到bcbjbcb这个最短的回文子串
继续分析，其实我们就是求s的最长回文前缀，那么我们怎么求解这个最长回文前缀呢？
我们将s反转后s的前缀将会变成后缀，所以我们将s和s的反转字符串拼在一起，就是寻找这个新字符串的最长公共前后缀，然后return reverse删除公共部分+s原字符串即为答案
tips： 这里我们在拼接两个字符串时，加了一个‘#’号，如果不加，例如aaa这种情况，拼接后变成aaaaaa，利用KMP求得为6，其实最长回文前缀为3，可以有效防止此类特殊情况出现

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

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String s = "aacecaaa";
		String res = shortestPalindrome(s);
		System.out.println(res);
	}
	public static String  shortestPalindrome(String s) {
		String reverse = "";
		int l = s.length()-1;
		for(int i = l;i>=0;i--) {
			reverse+=s.charAt(i);
		}
		String s1 = s+'#'+reverse;
		int max_len = getNext(s1);
		return reverse.substring(0, l-max_len)+s;
		
    }
	public static int getNext(String s) {
		int l = s.length();
		int i = 0;
		int j = -1;
		int [] next = new int[s.length()];
		next[0] = -1;
		
		while(i<l-1) {
			if(j==-1||s.charAt(i)==s.charAt(j)) {
				i++;
				j++;
				next[i] = j;
			}else
				j = next[j];
		}
		return next[l-1];		
	}

}

展开全文 >>

KMP

这是我第三次再次尝试学习KMP算法，以前总觉得是一个拦路虎，面对比我整个人还长的文章长度直接劝退，当再次遇到KMP后，痛定思痛下定决心来学习KMP算法，现在回头来看，只要静下心来对于聪明的你来说，一定不是难题
按照惯例，我们先来看一下暴力匹配是如何工作的

如下图所示我们利用双指针，i指向模板链的头部，j指向目标链的头部，开始逐个遍历是否相等，当不相等时，我们会令i回溯到i-j+1即模板链的下一个位置，j回溯到目标链的开头，重新开始匹配

当完全匹配时返回目标链在模板链中的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public int bfSearch(String s1,String s2){
    int l1 = s1.length;
    int l2 = s2.length;
    int i = 0;
    int j = 0;
    while(i<l1&&j<l2){
        if(s1.charAt(i)==s2.charAt(j)){
            i++;
            j++;
        }else{
            i = i-j+1;
            j = 0;
        }
    }
    if(j == l2){
        return i-j;
    }
    return -1;
}

在上述的暴力算法中，当目标链和模板链失配时，i会回溯到下一个位置再重新匹配，时间效率非常底下，那我们有没有办法不让i去回溯，只令指针j去移动目标链，这就是KMP算法的精髓所在，在KMP算法中我们利用部分匹配表，next数组来确定下一次j移动的位置
这也正是KMP算法的核心，部分匹配表
下面我们来解释一下什么是部分匹配表，例如字符串”abababca”的匹配表如下

例如:
index等于3对应的value值为2，表示以index等于3之前的字符串“abab”最长的公共前缀和后缀的长度
abab的前缀有a，ab，aba（不包括自身），后缀有b，ab，bab，最长公共部分ab长度为2，所以index=3位置对应的value为2，其他部分同理
了解了什么是部分匹配表，那么如何用部分比配表来加速匹配呢

如图所示，当失配时，我们发现只有最后一位是失配的，如果暴力解将i回溯会浪费大量的时间，此处我们利用next数组来是i的指针不发生回溯，只移动j指针，下面我们来分析利用next数组下一次将会移动到什么位置

如果指针能移动到_和D的对比处说明D之前的字符是匹配的，所以括号括起来的位置是相等的，又因为在目标链中，AB恰巧有一个相同的前缀AB，那么说明目标链的前缀和模板链的AB是相等的

即斜体下划线处不用再比较了，所以直接将目标链移动到如下位置

所以我们将这个过程通解化，即主字符串中i指针之前的 PMT[j −1] 位就一定与模式字符串的第 0 位至第 PMT[j−1] 位是相同的，保持i指针不动，然后将j指针指向模式字符串的PMT[j −1]位即可
为了利于程序的编写，我们将PMT数组做一些优化
我们发现，当字符失配时，影响j指针移动的是next[j-1],所以我们将next数组整体后移一位，并将next[0]默认值设为-1，为什么设为-1呢？

如图所示我们再首位就发现失配了，按照规则我们无法移动j指针，此时我们只能移动i指针去继续匹配，当我们执行i++，j++代码后，i后移，j不变，实现移动i指针

所以KMP的代码就呼之欲出了，此处我们假设next数组已知，下文中我们将解释如何求解 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public int KMP(String s1,String s2) {
		int l1 = s1.length();
		int l2 = s2.length();
		int i = 0;
		int j = 0;
		int [] next = new int[l2];
		while(i<l1&&j<l2) {
			if(j==-1||s1.charAt(i)==s2.charAt(j)) {
				i++;
				j++;
			}else {
				j = next[j];
			}
		}
		if(j==l2)
			return i-j;
		return -1;
	}

那么next数组应该怎么求呢？
我们使用错位法来求解，接下来我们将以字符串“abababca”来讲解如何求next数组

我们错开后可以看作i瞄准的是字符串的后缀（因为后缀不包括自身），同理j瞄准的就是前缀，前后缀的公共部分就是next的值，这个过程也可以看作是KMP的求解过程，其中我们要注意因为我们将next数组后移了一位，所以next[2]看的是i=1处的最长公共字串




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void getNext(int[] next,String s) {
        //这个求解过程也可以看作是KMP搜索，自身的前后缀的搜索
		int i = 0;
		int j = -1;
		next[0] = -1;
		while(i<s.length()-1) {
		    //在第一轮中，j==-1，所以i++，j++后i=1，j=0，实现错位比较
			if(j==-1||s.charAt(i)==s.charAt(j)) {
				i++;
				j++;
				next[i] = j;
			}else {
				j = next[j];
			}
		}
	}

至此，KMP算法结束！！！！！！！！！！！！

展开全文 >>

欧拉路径 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

说明:

如果存在多种有效的行程，你可以按字符自然排序返回最小的行程组合。例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前
所有的机场都用三个大写字母表示（机场代码）。
假定所有机票至少存在一种合理的行程。
示例 1:

输入: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
输出: ["JFK", "MUC", "LHR", "SFO", "SJC"]
示例 2:

输入: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
输出: ["JFK","ATL","JFK","SFO","ATL","SFO"]
解释: 另一种有效的行程是["JFK","SFO","ATL","JFK","ATL","SFO"]。但是它自然排序更大更靠后。
通过次数23,014提交次数52,781

首先我们先明白一个概念，什么是欧拉图，什么是欧拉路径
欧拉路径： 图M中一条路径能够经过图的每一条边，每一条边有且仅通过一次
欧拉回路： 就是一条封闭的欧拉路径
欧拉图： 含有欧拉回路的图
有向图欧拉图：
欧拉路径：有一个点出度比入度多1(起点)，有一个点入度比出度多1(终点)，其余点出度等于入度；
欧拉回路：每个顶点出度等于入度；
无向图欧拉图：
欧拉路径：有且仅有两个点的入度为1，分别是起点和终点；
欧拉回路：图中所有顶点的度数都是偶数，并且该图是连通图；
主要思路：
本体的题意表明至少存在一条欧拉路径，当存在多条欧拉路径时，我们输出字典序最小的哪一条路径，为了保证最终的结果是字典序最小的路径，我们贪心的去选择下一次目的地。
1.从题目中给定的“JFK”为起点开始遍历整张图
2.接下来我们dfs遍历这些节点的邻接节点，并且将已经遍历过的边给删除
3.当我们使一个节点没有邻接边时，说明此点已经进入死胡同，那么我们将其加入到结果集中
4.随着递归的出栈就能的到一道“JDK”为起点的欧拉路径
所用的数据结构
由于map中的key可能对应多个值，且这些值明显的具有字典序，那么我们使用优先队列，优先队列默认是小顶堆，poll出堆顶字典序最小的元素，很明显复合我们这个题目的要求

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution {
    Map<String,PriorityQueue<String>> map = new HashMap<>();
	List<String> res = new ArrayList<>();
    public List<String> findItinerary(List<List<String>> tickets) {
          for(List<String> ticket : tickets) {
			String start = ticket.get(0);
			String end = ticket.get(1);
			if (!map.containsKey(start)) {
                map.put(start, new PriorityQueue<String>());
            }
			map.get(start).offer(end);
		}
		dfs("JFK");
		Collections.reverse(res);
		return res;
    }
    public void dfs(String cur) {
		while(map.containsKey(cur)&&map.get(cur).size()>=1) {
			String temp = map.get(cur).poll();
			dfs(temp);
		}
		res.add(cur);
	}
}

展开全文 >>

电话号码的字母组合 

1
2
3
4
5
6
7
8
9
10
11
12
给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。



示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
说明:
尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

主要思路:
类似于这种回溯排列问题都有固定的模板，难点在于书写搜索范围，本题思路与递增子序列问题大同小异，我们用map存放数字映射的字母，具体代码如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Solution {
    List<String> res = new ArrayList<>();
	Map<Integer,String> map = new HashMap<>();
    public List<String> letterCombinations(String digits) {
        //关于字符串的判断，统统用equals方法
        if(digits.equals(""))
			return res;
        map.put(2, "abc");
		map.put(3, "def");
		map.put(4, "ghi");
		map.put(5, "jkl");
		map.put(6, "mno");
		map.put(7, "pqrs");
		map.put(8, "tuv");
		map.put(9, "wxyz");
		StringBuffer path = new StringBuffer();
		dfs(digits, path, 0);
		return res;
    }
    public void dfs(String str,StringBuffer path, int i) {//i表示组成字符串的第i位
        //结束条件
		if(i==str.length()) {
			res.add(path.toString());
			return;
		}
		int index = str.charAt(i)-'0';
		String string = map.get(index);
		//遍历map对应的映射
		for(int j = 0;j<string.length();j++) {
			path.append(string.charAt(j));
			dfs(str, path, i+1);
			path.deleteCharAt(i);
		}
	}
}

展开全文 >>

递增子序列 

1
2
3
4
5
6
7
8
9
10
11
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

输入: [4, 6, 7, 7]
输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]
说明:

给定数组的长度不会超过15。
数组中的整数范围是[-100,100]。
给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

主要思路：
本题主要考察回溯算法的理解，类似于全排列的思路，根据题目进行剪枝，最主要是如何去重，因为数组中存在重复的数字所以在选择的过程中可能会出现重复的子序列，所以根据去重的思路我们主要分为两种，关于选数的分递归可以用for循环和选与不选两种思路，此处我们Set方法用for循环，剪枝用选与不选的方法
一、Set去重 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution {
    List<List<Integer>> res = new ArrayList<>();
    Set<Object> set = new HashSet<>();//去重
    public List<List<Integer>> findSubsequences(int[] nums) {
        List<Integer> path = new ArrayList<>();
		dfs(0,nums,path);
		return res;
    }
    private void dfs(int start, int[] nums,List<Integer> path) {
		if(path.size()>=2&&!set.contains(path)) {
		    //到达最深处拷贝path
			set.add(new ArrayList<>(path));
			res.add(new ArrayList<>(path));
		}
		for(int i = start;i<nums.length;i++) {
			if(path.size()==0||path.get(path.size()-1)<=nums[i]) {
				path.add(nums[i]);
				dfs(i+1, nums,path);
				path.remove(path.size()-1);
			}
		}
		
	}
}

二、剪枝去重
那如何保证没有重复呢？我们需要给「不选择」做一个限定条件，只有当当前的元素不等于上一个选择的元素的时候，才考虑不选择当前元素，直接递归后面的元素。因为如果有两个相同的元素，我们会考虑这样四种情况：

前者被选择，后者被选择
前者被选择，后者不被选择
前者不被选择，后者被选择
前者不被选择，后者不被选择
其中第二种情况和第三种情况其实是等价的，我们这样限制之后，舍弃了第二种，保留了第三种，于是达到了去重的目的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        List<Integer> path = new ArrayList<>();
		dfs(0,nums,path,Integer.MIN_VALUE);
		return res;
    }
    private void dfs(int index, int[] nums,List<Integer> path,int last) {
		if(index == nums.length) {
			if(path.size()>=2)
				res.add(new ArrayList<>(path));
			return;
		}
		if(nums[index]>=last) {
			path.add(nums[index]);
			dfs(index+1, nums, path, nums[index]);
			path.remove(path.size()-1);
		}
		if(nums[index]!=last)
			dfs(index+1, nums, path, last);
		
	}
}

展开全文 >>

全排列 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

主要思路：
这是一道经典且入门级的回溯算法题目，实质就是利用递归来实现遍历的效果，回溯的过程体现在如何去撤销选择，使状态恢复到上一次递归之前，回溯的另一重要特性就是剪枝，通过剪枝优化算法，是的遍历的次数减少，这在以后的刷题中慢慢会理解的更深，还有对java值传递的特性一步更深的理解 

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
public static List<List<Integer>> permute(int[] nums) {
		int len = nums.length;
		//用来判断nums中下标为i的数字是否被选过
		boolean [] visited = new boolean[nums.length];
		//结果集
		List<List<Integer>> res = new ArrayList<>();
		//中间的每一次结果集
		List<Integer> path = new ArrayList<>();
		dfs(nums,len,0,path,res,visited);
		return res;
    }
	public static void dfs(int[] nums, int len, int depth, List<Integer> path, List<List<Integer>> res, boolean[] visited) {
		//depth表示选了几个数，当选了len个数时，结束
		if(depth==len) {
		    //由于我们全部过程只使用了一个结果集，当结束递归时，我们会恢复到最初状泰
		    //此时返回的res会是空解，所以在最深处我们进行一次拷贝
			res.add(new ArrayList<>(path));
			return;
		}
		for(int i = 0;i<len;i++) {
			if(!visited[i]) {
				path.add(nums[i]);
				visited[i] = true;
				dfs(nums, len, depth+1, path, res, visited);
				//恢复操作
				visited[i] = false;
				path.remove(path.size()-1);
			}
		}
	}

展开全文 >>

蛙广志的日记

今天是8.24日，距离大二开学还有3天的时间，总觉得自己要有点压迫力才能去认真学习，来自同龄人的压力，来自将来马上步入社会，离开象牙塔的压力
总觉得自己能做成一番事件，自学对自己来说并不是一项挑战，但混乱的学习路线，悠然悠然的学习进度，还有来自大学无用的课程设置，总让自己心烦意乱，害呀，心好烦啊，所以开设此学习目标的子博客，督促自己完成近期目标
九月目标
1.()8.27-9.11完成期末考试，期间不要被室友的压力而心慌意乱，每天一到leetcode，目前73题，考试结束前必须达到90题
2.()9.11-9.13完成剩余的jdbc课程，并整理博客
3.()9.14-9.16复习反射和IO流，整理博客
4.()9.16-9.18复习HTML.CSS.JS
5.()9.19-9.22 jquary
6.()9.22-9.25 ajax
剩余时间用来完成上述任务，并参加一次leetcode周赛

展开全文 >>

字符串的循环节 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

示例 1:

输入: "abab"

输出: True

解释: 可由子字符串 "ab" 重复两次构成。
示例 2:

输入: "aba"

输出: False
示例 3:

输入: "abcabcabcabc"

输出: True

解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)

思路分析：
一、暴力法：
经过分析我们不难发现
1.s的循环节一定是s字符串的前缀字符串
2.s的长度一定是循环节的n倍
3.最长循环节的长度不会超过总长的一半（可用于优化暴力法） 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
	public static boolean repeatedSubstringPattern(String s) {
		 int slen = s.length();
		 for(int i = 0;i<s.length()/2;i++) {
			 String temp = s.substring(0, i+1);
			 int tlen = temp.length();
			 if(slen%tlen!=0)
				 continue;
			 int j,k;
			 for(j = tlen,k = 0;j<slen;j++,k++) {
				 if(k==tlen)
					 k = 0;
				 if(s.charAt(j)!=temp.charAt(k))
					 break;
			 }
			 if(j==slen)
				 return true;
		 }
		 return false;
		 
}

二、暴力法的优化：
其实我们并不需要取截取字符串，我们可以用双指针用来确定字符串的头尾 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static boolean repeatedSubstringPattern(String s) {
	        int n = s.length();
	        for (int i = 1; i * 2 <= n; ++i) {//表示循环节的长度
	            if (n % i == 0) {
	                boolean match = true;
	                for (int j = i; j < n; ++j) {
	                    if (s.charAt(j) != s.charAt(j - i)) {
	                 //第一次是第二个字串和第一个比，后面是第三个和第二个比，以此类推
	                        match = false;
	                        break;
	                    }
	                }
	                if (match) {
	                    return true;
	                }
	            }
	        }
	        return false;
}

三、构建双字符串的方法：两行代码搞定

1
2
3
public static boolean repeatedSubstringPattern(String s) {
    return (s+s).indexOf(s,1) != s.length
}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

蛙广志<br><br>总要变强<br>