算法综合实验——背包问题


阅读数: 次   

概述

本文是我大二算法分析实验的综合大实验，可能跟大家的比起来难度微不足道，希望能对你有帮助🤪

0/1背包

问题描述：

给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大?

对于一种物品，要么装入背包，要么不装。所以对于一种物品的装入状态可以取0和1.我们设物品i的装入状态为xi,xi∈ (0,1)，此问题称为0-1背包问题。

1.递归求解

我们用F(n,C)表示将前n个物品放进容量为C的背包里，得到的最大的价值。

我们用自顶向下的角度来看，假如我们已经进行到了最后一步（即求解将n个物品放到背包里获得的最大价值），此时我们便有两种选择

  1. 不放第n个物品，此时总价值为F(n-1,C)
  2. 放置第n个物品，此时总价值为Vn+F(n-1,C-Wn)

两种选择中总价值最大的方案就是我们的最终方案:F(i,C)=max(F(i−1,C),v(i)+F(i−1,C−w(i)))

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
/**
	 * 递归解决
	 * @param w		物品的重量数组
	 * @param v		物品的价值数组
	 * @param index 当前待选择的物品索引
	 * @param capacity	当前背包有效容量
	 * @return	最大价值
	 */
private static int recursion(int[] w,int[] v,int index,int capacity) {
    //基准条件：如果索引无效或者容量不足，直接返回当前价值0
    if(index<0||capacity<=0) {
        return 0;
    }
    //不放第index个物品所得价值
    int res = recursion(w, v, index-1, capacity);
    //放第index个物品所得价值（前提是：第index个物品可以放得下）
    if(w[index]<=capacity) {
        res = Math.max(res, v[index]+recursion(w, v, index-1, capacity-w[index]));
    }
    return res;
}
public static int knapSack(int[] w, int[] v, int C) {
    int size = w.length;
    return solveKS(w, v, size - 1, C);
}

public static void main(String[] args){
    int[] w = {2,1,3,2};
    int[] v = {12,10,20,15};
    System.out.println(knapSack(w,v,5));
}

2.记忆化搜索(自顶向下备忘录法)

我们可以将已经求得的子问题的结果保存下来，这样对子问题只会求解一次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
	 * 自顶向下备忘录法
	 * @param w
	 * @param v
	 * @param index
	 * @param capacity
	 * @return
	 */
private static int top2buttom(int[] w,int[] v,int index,int capacity,int[][] memo) {
    if(index<0||capacity<=0) {
        return 0;
    }
    //如果此子问题已经求解过，则直接返回上次求解的结果
    if(memo[index][capacity]!=0)return memo[index][capacity];
    //不放第index个物品所得价值
    int res = recursion(w, v, index-1, capacity);
    //放第index个物品所得价值（前提是：第index个物品可以放得下）
    if(w[index]<=capacity) {
        res = Math.max(res, v[index]+recursion(w, v, index-1, capacity-w[index]));
    }
    //添加子问题的解，便于下次直接使用
    memo[index][capacity] = res;
    return res;
}

3.动态规划算法

通过反证法可证明此问题符合动态规划算法的最优子结构性质，可以通过动态规划来求解。了解动态规划

img

img

img

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
/**
	 * 动态规划(自底向上)算法
	 * @param w
	 * @param v
	 * @param C
	 * @return
	 */
public static int buttom2top(int[] w,int[] v,int C) {
    int size = w.length;
    if(size == 0 || C<=0)return 0;
    int[][] dp = new int[size][C+1];
    //初始化第一行:仅考虑容量为C的背包放第0个物品的情况
    for(int i=0;i<=C;i++) {
        dp[0][i] = w[0]<=i? v[0]:0;//如果容量可以放，就是第一个的价值，否则放不了为0
    }
    //根据此逐步填充
    for(int i=1;i<size;i++) {//每个物品的循环
        for(int j=0;j<=C;j++) {
            dp[i][j] = dp[i-1][j];//要放此物品，说明前面的已经是最优解，根据这个最优解为基准看是增加还是不增加这个物品
            if(w[i]<=j) {//如果容量够叫放进去试试看
                dp[i][j] = Math.max(dp[i][j], v[i]+dp[i-1][j-w[i]]);
            }
        }
    }
    return dp[size-1][C];
}

4.动态规划的空间优化

上面的动态规划算法使用了O(n*C)的空间复杂度（因为我们使用了二维数组来记录子问题的解），其实我们完全可以只使用一维数组来存放结果，但同时我们需要注意的是，为了防止计算结果被覆盖，我们必须从后向前分别进行计算

我们可以知道，当我们利用一维数组进行记忆化的时候，我们只需要使用到当前位置的值和该位置之前的值，举个例子：假设我们要计算F(i,4),我们需要用到的值为F(i−1,4)和F(i−1,4−w(i)),因此为了防止结果被覆盖，我们需要从后向前依次计算结果

为保证每个物品只能使用一次，我们倒序遍历所有j的值，这样在更新dp[j]的时候，dp[j-list[i].w]的值尚未被修改，就不会出现一个物品重复使用的问题。

优化后的状态转移方程：dp[j] = max{ dp[j-list[i].w] + v, dp[j] }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
	 * 动态规划的空间优化
	 * 我们可以用一维数组来存储临时的值
	 * 如果我们还按照顺序来，计算的值需要前面的值：
	 * 假设我们要计算F(i,4),我们需要用到的值为F(i−1,4)和F(i−1,4−w(i))，如果前面的值被修改了，那就不准确了
	 * 因此为了防止结果被覆盖，我们需要从后向前依次计算结果
	 * @return
	 */
private static int B2TPlus(int[] w,int[] v,int C) {
    int size = w.length;
    if(size == 0 || C<=0)return 0;
    int[] dp = new int[C+1];
    //初始化第一行
    for (int i = 0; i <= C; i++) {
        dp[i] = w[0] <= i ? v[0] : 0;
    }
    for(int i=1;i<size;i++) {//遍历每一个商品要不要添加
        for(int j=C;j>=w[i];j--) {//从后向前
            dp[j] = Math.max(dp[j], v[i]+dp[j-w[i]]);
        }
    }
    return dp[C];
}

复杂度分析：其状态数量为nC, n为物品数量，C为背包总体积，状态转移复杂度为O(1)，所以综合时间复杂度为O(n*C)，优化后的空间复杂度仅为O(C)。

5.回溯法

回溯法：为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数(bounding function)来处死那些实际上不可能产生所需解的活结点，以减少问题的计算量。这种具有限界函数的深度优先生成法称为回溯法。

img

对于有n种可选物品的0/1背包问题，其解空间由长度为n的0-1向量组成,可用子集数表示。同时在构建树过程中还需考虑容量是否够来判断有无右子树。在搜索解空间树时，只要其左儿子结点是一个可行结点，搜索就进入左子树。当右子树中有可能包含最优解时就进入右子树搜索。

这里所谓回溯就是进入之后比较一下看看有没有进错，进错了就回溯回去进另一个。

这里给出思想，时间紧急，明天就要交实验报告了，代码日后研究填坑。

完全背包

问题描述：

有N种物品和一个容量为T的背包，每种物品都就可以选择任意多个，第i种物品的价值为v[i]，体积为w[i]，求解：选哪些物品放入背包，可卡因使得这些物品的价值最大，并且体积总和不超过背包容量。

跟01背包一样，完全背包也是一个很经典的动态规划问题，不同的地方在于01背包问题中，每件物品最多选择一件，而在完全背包问题中，只要背包装得下，每件物品可以选择任意多件。从每件物品的角度来说，与之相关的策略已经不再是选或者不选了，而是有取0件、取1件、取2件…直到取⌊T/Vi⌋（向下取整）件。

1.分析贪心算法的可行性

看到可以选择任意多件，你也许会想，那还不容易，选性价比最高的就好了。

于是开启贪婪模式，把每种物品的价格除以体积来算出它们各自的性价比，然后只选择性价比最高的物品放入背包中。

嗯，听起来好像没什么毛病，但仍旧有一个问题，那就是同一种物品虽然可以选择任意多件，但仍旧只能以件为单位，也就是说单个物品是无法拆分的，不能选择半件，只能多选一件或者少选一件。这样就造成了一个问题，往往无法用性价比最高的物品来装满整个背包，比如背包空间为10，性价比最高的物品占用空间为7，那么剩下的空间该如何填充呢？

你当然会想到用性价比第二高的物品填充，如果仍旧无法填满，那就依次用第三、第四性价比物品来填充。

听起来似乎可行，但我只需要举一个反例便能证明这个策略行不通。

想要举反例很简单，比如只有两个物品：物品A：价值5，体积5，物品B：价值8：体积7，背包容量为10，物品B的性价比显然要比物品A高，那么用贪心算法必然会选择放入一个物品B，此时，剩余的空间已无法装下A或者B，所以得到的最高价值为8，而实际上，选择放入两个物品A即可得到更高的价值10。所以这里贪心算法并不适用。

以上形象的分析摘自弗兰克的猫博主的话

2.递归法

我们只需要找到递推关系式，就很容易使用递归解法来求解了。

ks(i,t) = max{ks(i-1,t),ks(i-1, t - V[i] k) + P[i] k}; （0 <= k * V[i] <= t）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
	 * 递归法
	 * ks(i,t) = max{ks(i-1,t),ks(i-1, t - V[i] * k) + P[i] * k}; （0 <= k * V[i] <= t）
	 * @param index	当前待选择的物品索引
	 * @param c	当前背包有效容量
	 * @return
	 */
private static int recursion(int index,int c) {
    //基准条件：如果索引无效或者容量不足，直接返回当前价值0
    if(index<0||c<=0) {
        return 0;
    }
    //不放第index个物品所得价值
    int res = recursion(index-1, c);
    //放第index个物品所得价值（前提是：第index个物品可以放得下）
    if(w[index]<=c) {
        // 取k个物品index，取其中使得总价值最大的k
        for(int k=1;k*w[index]<=c;k++) {
            res = Math.max(res,k*v[index]+ recursion(index-1, c-k*w[index]));
        }
    }
    return res;
}

如果你对比一下01背包问题中的递归解法，就会发现唯一的区别便是这里多了一层循环，因为01背包中，对于第i个物品只有选和不选两种情况，只需要从这两种选择中选出最优的即可，而完全背包问题则需要在k种选择中选出最优解，这便是最内层循环在做的事情。

3.动态规划

那这个问题可以不可以像01背包问题一样使用动态规划来求解呢？来证明一下即可。

首先，先用反证法证明最优化原理：

假设完全背包的解为F(n1,n2,…,nN)（n1，n2 分别代表第1、第2件物品的选取数量），完全背包的子问题为，将前i种物品放入容量为t的背包并取得最大价值，其对应的解为：F(n1,n2,…,ni)，假设该解不是子问题的最优解，即存在另一组解F(m1,m2,…,mi)，使得F(m1,m2,…,mi) > F(n1,n2,…,ni)，那么F(m1,m2,…,mi,…,nN) 必然大于 F(n1,n2,…,nN)，因此 F(n1,n2,…,nN) 不是原问题的最优解，与原假设不符，所以F(n1,n2,…,ni)必然是子问题的最优解。

再来看看无后效性：

对于子问题的任意解，都不会影响后续子问题的解，也就是说，前i种物品如何选择，只要最终的剩余背包空间不变，就不会影响后面物品的选择。即满足无后效性。

因此，完全背包问题也可以使用动态规划来解决。

3.1自上而下记忆法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
	 * 自上而下记忆法
	 * @param i
	 * @param c
	 * @param memo
	 * @return
	 */
private static int top2buttom(int i,int c,int[][] memo) {
    if(i<0||c<=0) {
        return 0;
    }
    //如果此子问题已经求解过，则直接返回上次求解的结果
    if(memo[i][c]!=0)return memo[i][c];
    //不放第index个物品所得价值
    int res = recursion(i-1, c);
    //放第index个物品所得价值（前提是：第index个物品可以放得下）
    if(w[i]<=c) {
        // 取k个物品index，取其中使得总价值最大的k
        for(int k=1;k*w[i]<=c;k++) {
            res = Math.max(res,k*v[i]+ recursion(i-1, c-k*w[i]));
        }
    }
    //添加子问题的解，便于下次直接使用
    memo[i][c] = res;
    return res;
}

3.2自底向上填表法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
	 * 自底向上填表法
	 * @param C
	 * @return
	 */
private static int buttom2top(int C) {
    int size = w.length;
    if(size == 0 || C<=0)return 0;
    int[][] dp = new int[size][C+1];
    //初始化第一行:仅考虑容量为C的背包放第0个物品的情况
    for(int i=0;i<=C;i++) {
        dp[0][i] = w[0]<=i ?(i/w[0])*w[0]:0;
    }
    //根据此逐步填充
    for(int i=1;i<size;i++) {
        for(int j=0;j<=C;j++) {
            dp[i][j] = dp[i-1][j];
            if(j>=w[i]) {
                for(int k=1;k*w[i]<=j;k++) {
                    dp[i][j] = Math.max(dp[i][j], k*v[i]+dp[i-1][j-k*w[i]]);
                }
            }
        }
    }
    return dp[size-1][C];
}

3.3动态规划的空间优化

跟01背包问题一样，完全背包的空间复杂度也可以进行优化，具体思路这里就不重复介绍了，可以翻看前面的01背包问题优化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
	 * 动态规划的空间优化
	 * @param C
	 * @return
	 */
private static int B2TPlus(int C) {
    int size = w.length;
    if(size == 0 || C<=0)return 0;
    int[] dp = new int[C+1];
    //初始化第一行:仅考虑容量为C的背包放第0个物品的情况
    for(int i=0;i<=C;i++) {
        dp[i] = w[0]<=i ?(i/w[0])*w[0]:0;
    }
    for(int i=1;i<size;i++) {//遍历每一个商品要不要添加
        for(int j=C;j>=w[i];j--) {//从后向前
            for(int k=1;k*w[i]<=j;k++) {
                dp[j] = Math.max(dp[j], k*v[i]+dp[j-k*w[i]]);
            }
        }
    }
    return dp[C];
}

其实完全背包问题也可以转化成01背包问题来求解，因为第i件物品最多选 ⌊T/Vi⌋(向下取整) 件，于是可以把第i种物品转化为⌊T/Vi⌋件体积和价值相同的物品，然后再来求解这个01背包问题。具体方法这里就不多说了，留给大家自行解决。

多重背包

问题描述：

有N种物品和一个容量为T的背包，第i种物品最多有M[i]件可用，价值为v[i]，体积为w[i]，求解：选哪些物品放入背包，可以使得这些物品的价值最大，并且体积总和不超过背包容量。

对比一下完全背包，其实只是多了一个限制条件，完全背包问题中，物品可以选择任意多件，只要你装得下，装多少件都行。

1.递归法

都是老菜了，直接上桌：

1
ks(i,t) = max{ks(i-1, t - V[i] * k) + P[i] * k}; （0 <= k <= M[i] && 0 <= k * V[i] <= t）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private int ks(int i, int t){
    int result = 0;
    if (i == 0 || t == 0){
        // 初始条件
        result = 0;
    } else if(V[i] > t){
        // 装不下该珠宝
        result = ks(i-1, t);
    } else {
        // 可以装下
        // 取k个物品i，取其中使得总价值最大的k
        for (int k = 0; k <= M[i] && k * V[i] <= t; k++){
            int tmp2 = ks(i-1, t - V[i] * k) + P[i] * k;
            if (tmp2 > result){
                result = tmp2;
            }
        }
    }
    return result;
}

2.动态规划

仅仅多了一个判断条件而已，所以只要弄懂了完全背包，多重背包就不值一提了。

2.1自上而下记忆法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private int ks2(int i, int t){
    // 如果该结果已经被计算，那么直接返回
    if (results[i][t] != null) return results[i][t];
    int result = 0;
    if (i == 0 || t == 0){
        // 初始条件
        result = 0;
    } else if(V[i] > t){
        // 装不下该珠宝
        result = ks2(i-1, t);
    } else {
        // 可以装下
        // 取k个物品，取其中使得价值最大的
        for (int k = 0; k <= M[i] && k * V[i] <= t; k++){
            int tmp2 = ks2(i-1, t - V[i] * k) + P[i] * k;
            if (tmp2 > result){
                result = tmp2;
            }
        }
    }
    results[i][t] = result;
    return result;
}

2.2自下而上填表法

1
2
3
4
5
6
7
8
9
10
public void solve3() {
    for (int i = 0; i < P.length; i++){
        for (int j = 0; j <= T; j++){
            for (int k = 0; k <= M[i] && k * V[i] <= j; k++){
                dp[i+1][j] = Math.max(dp[i+1][j], dp[i][j-k * V[i]] + k * P[i]);
            }
        }
    }
    System.out.println("最大价值为：" + dp[P.length][T]);
}

2.3优化空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
private int ksp(int i, int t){
    // 开始填表
    for (int m = 0; m < i; m++){
        // 考虑第m个物品
        // 分两种情况
        // 1： M[m] * V[m] > T 则可以当做完全背包问题来处理
        if (M[m] * V[m] >= T) {
            for (int n = V[m]; n <= t ; n++) {
                newResults[n] = Math.max(newResults[n], newResults[n - V[m]] + P[m]);
            }
        } else {
            // 2： M[m] * V[m] < T 则需要在 newResults[n-V[m]*k] + P[m] * k 中找到最大值，0 <= k <= M[m]
            for (int n = V[m]; n <= t ; n++) {
                int k = 1;
                while (k < M[m] && n > V[m] * k ){
                    newResults[n] = Math.max(newResults[n], newResults[n - V[m] * k] + P[m] * k);
                    k++;
                }
            }
        }
        // 可以在这里输出中间结果
        System.out.println(JSON.toJSONString(newResults));
    }
    return newResults[newResults.length - 1];
}

贪心解决0/1背包问题

问题描述：

随机生成500个0/1背包问题（问题规模可以相对较小），如果使用贪心算法进行求解，统计能够求得最优值的概率，没有求得最优值，统计最坏的情况误差有多大。实验结果跟实验设置的参数（如：背包容量）关系很大，简要分析参数对结果的影响。

1.分析

贪心算法求解背包问题的话前文也提到过，优先选择性价比最高的，选中或者不行再考虑性价比第二，第三……

用贪心算法处理这个问题的难点在于如何知道第几个性价比最高(这个很容易实现)，性价比第二，第三……(有难度)

我们想到了可以将价格、重量、性价比都封装到一个对象中，这个对象在组成一个对象数组，这样通过对对象数组中性价比成员的排序，我们可以得到对应的价格重量。当然，我们还有一种更简便的方法：使用数据结构MAP，键是性价比，值是索引，来得到和之前一样的效果。（空指针异常，原因未知）

下面我们分析这个随机生成500个由哪些随机参数组成随机性：背包容量是必须的，而背包容量的确定我们可以参照物品个数及物品的重量区间，每个物品只有选择和被选择，所以我们确定背包容量时折个中，确保随机性。

我们选择4~12个物体，每个物体的重量区间为[5~20]，背包容量根据物体个数*区间中位数13获得，物体的价值在1~20之间。

2.贪心算法实现

创建Knapsack对象

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
public class Knapsack implements Comparable<Knapsack> {
    /** 物品重量 */
    private int weight;
    /** 物品价值 */
    private int value;
    /** 单位重量价值 */
    private double unitValue;

    public Knapsack(int weight, int value) {
        this.weight = weight;
        this.value = value;
        this.unitValue = (weight == 0) ? 0 : (double)value / weight;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public double getUnitValue() {
        return unitValue;
    }

    @Override
    public int compareTo(Knapsack snapsack) {
        double value = snapsack.unitValue;
        if (unitValue > value)
            return 1;
        if (unitValue < value)
            return -1;
        return 0;
    }

}

算法实现(注释为失败的尝试😭)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
private static int greedy(int[] w,int[] v,int C) {
		int size = w.length;
//		double[] keys = new double[size];
//		Map<Double, Integer> map = new HashMap<Double, Integer>();
//		for(int i=0;i<size;i++) {
//			map.put(w[i]==0?0:(double)v[i]/w[i], i);
//			keys[i] = w[i]==0?0:(double)v[i]/w[i];
//		}
//		Bubble(keys);
//		int tempC = C;//记录当前容量
//		int res = 0;
//		for(int i=0;i<size;i++) {
//			int n = map.get(keys[i]);
////			map.remove(keys[i]);
//			//判断当前物品是否可以放入背包中，若不能则继续循环，查找下一个物品
//			if(tempC<w[map.get(keys[i])])continue;
//			tempC -= w[map.get(keys[i])];
//			res += v[map.get(keys[i])];
//		}
//		return res;
		Knapsack[] bags = new Knapsack[size];
		for(int i=0;i<size;i++) {
			bags[i] = new Knapsack(w[i], v[i]);
		}
		// 对背包按单位重量价值从大到小排序
        Arrays.sort(bags, Collections.reverseOrder());
        int tempC = C;//记录当前容量
        int res = 0;
        for(int i=0;i<size;i++) {
        	 //判断当前物品是否可以放入背包中，若不能则继续循环，查找下一个物品
        	if(tempC<bags[i].getWeight())continue;
        	tempC -= bags[i].getWeight();
        	res += bags[i].getValue();
        }
        return res;
	}

3.测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) {
    int MaxError = 0;
    int count = 0;
    for(int i=0;i<500;i++) {
        Random random = new Random(i);
        int size = random.nextInt(9)+4;//物体数量：4~12
        int C = size*13;
        int[] w = new int[size];
        int[] v = new int[size];
        for(int j=0;j<size;j++) {
            w[j] = random.nextInt(16)+5;//重量区间为[5~20]
            v[j] = random.nextInt(20)+1;//物体的价值在1~20之间。
        }
        int greedy = greedy(w, v, C);
        int real = B2TPlus(w, v, C);
        if(greedy==real)count++;
        MaxError = Math.max(MaxError, greedy-real>0?greedy-real:real-greedy);
    }

    System.out.println("用贪心算法求得最优值概率为"+(double)count/500);
    System.out.println("最坏的情况误差有"+MaxError);
}

image-20200621222940378

结语

以上就是本学期最后一个实验呐，算法的路还很长，我只是刚刚踏入海滩拾贝而已，真正的深海等着我去翻越。老实说，这是我这学期最上心的一门课了(虽然也是一节课没听)，希望我微薄的努力不要白费吧😁给个好分数吧老师！！！！这个对我真的很重要啊啊啊啊啊啊

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

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>谢谢大家