算法笔记_第十章

第十章上机训练

10(上机)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;

//PAT A1034
int n,k;
const int maxn = 2010;
const int INF = 1000000000;
int G[maxn][maxn]={0}; //邻接矩阵,无向图
int weight[maxn]={0}; //节点的度,用来找head
int num=0; //total people
bool visit[maxn]={false};
map<string,int> Gang;
map<string,int> stringToInt;
map<int,string> intToString;

//string to int
int change(string str)
{
    if(stringToInt.find(str)!=stringToInt.end()) return stringToInt[str];
    else{
        stringToInt[str]=num;
        intToString[num]=str;
        return num++;
    }
}

//深度遍历一个节点
void DFS(int nowvisit,int &head,int &numMember,int &totalValue)
{
    numMember++;
    visit[nowvisit]=true;
    if(weight[nowvisit]>weight[head]) head=nowvisit;
    for(int i=0;i<num;i++){
        if(G[nowvisit][i]>0){
            totalValue+=G[nowvisit][i];
            G[nowvisit][i]=G[i][nowvisit]=0;
            if(visit[i]==false) DFS(i,head,numMember,totalValue);
        }
    }
}

//遍历整个图
void DFSTrave()
{
    for(int i=0;i<num;i++){
        if(visit[num]==false){
            int head=i,numMember=0,totalValue=0;
            DFS(i,head,numMember,totalValue);
            if(numMember>2&&totalValue>k) Gang[intToString[head]]=numMember;
        }
    }
}

int main()
{
    cin>>n>>k;
    for(int i=0;i<n;i++) visit[i]=false;
    int w; //weight
    string str1,str2;
    for(int i=0;i<n;i++){
        cin>>str1>>str2>>w;
        int id1=change(str1);
        int id2=change(str2);
        weight[id1]+=w;
        weight[id2]+=w;
        G[id1][id2]+=w;
        G[id2][id1]+=w;
    }
    DFSTrave();
    printf("%d\n",Gang.size());
    map<string,int>::iterator it;
    for(it=Gang.begin();it!=Gang.end();it++)
        cout<<it->first<<" "<<it->second<<endl;
    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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;

//PAT A1076
const int maxn=1010;
struct node
{
    int id;
    int layer;
};
vector<node> Adj[maxn];
bool inq[maxn]={false};
//本题不用每个节点都BFS一遍，写一个单节点的BFS就好
int BFS(int index,int layer_max)
{
    int numForward=0;
    queue<node> q;
    node start;
    start.id=index;
    start.layer=0;
    q.push(start);
    inq[start.id]=true;
    while(!q.empty()){
        node top=q.front();
        q.pop();
        int nowid=top.id;
        for(int i=0;i<Adj[nowid].size();i++){
            node next=Adj[nowid][i];
            next.layer=top.layer+1;
            if(inq[next.id]==false&&next.layer<=layer_max){
                q.push(next);
                inq[next.id]=true;
                numForward++;
            }
        }
    }
    return numForward;
}

int main()
{
    node main;
    int n,l;
    scanf("%d%d",&n,&l);
    int numF,id;
    for(int i=1;i<=n;i++){
        main.id=i;
        scanf("%d",&numF);
        for(int j=0;j<numF;j++){
            scanf("%d",&id);
            Adj[id].push_back(main);
        }
    }
    int query,s;
    scanf("%d",&query);
    for(int i=0;i<query;i++){
        memset(inq,false,sizeof(inq));
        scanf("%d",&s);
        int numForward=BFS(s,l);
        printf("%d\n",numForward);
    }
    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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;

//PAT A1013
//分析完后，如果用DFS就是求连通块
//DFS+建立邻接表+否访问过的数组

const int maxn=1010;
vector<int> B[maxn];
bool visit[maxn]={false};
int n,m,k;

int deletePoint;

void DFS(int index)
{
    if(index==deletePoint) return;
    visit[index]=true;
    for(int i=0;i<B[index].size();i++){
        if(visit[B[index][i]]==false)
            DFS(B[index][i]);
    }
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    int a,b;
    for(int i=0;i<m;i++){
        scanf("%d%d",&a,&b);
        B[a].push_back(b);
        B[b].push_back(a);
    }
    for(int i=0;i<k;i++){
        scanf("%d",&deletePoint);
        memset(visit,false,sizeof(visit));
        int block=0;
        for(int j=1;j<=n;j++){
            if(j!=deletePoint && visit[j]==false){
                DFS(j);
                block++;
            }
        }
        printf("%d\n",block-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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;

//PAT A1021
// DFS 看是否连通
// 这题按正常思路做的，23分，有一个节点超时了
const int MAXN=10010;
vector<int> G[MAXN];
set<int> best;
bool visit[MAXN]={false};
int max_depth=0;

void DFS(int index,int depth)
{
    visit[index]=true;
    if(depth>max_depth){
        best.clear();
        best.insert(index);
        max_depth=depth;
    }
    else if(depth==max_depth){
        best.insert(index);
    }
    for(int i=0;i<G[index].size();i++){
        if(visit[G[index][i]]==false){
            DFS(G[index][i],depth+1);
        }
    }
}

void dfs(int index)
{
    visit[index]=true;
    for(int i=0;i<G[index].size();i++){
        if(visit[G[index][i]]==false){
            dfs(G[index][i]);
        }
    }
}

int main()
{
    int n;
    scanf("%d",&n);
    int a,b;
    for(int i=0;i<n-1;i++){
        scanf("%d%d",&a,&b);
        G[a].push_back(b);
        G[b].push_back(a);
    }
    // 先求是否连通
    int blocks=0;
    for(int i=1;i<=n;i++){
        if(visit[i]==false){
            dfs(i);
            blocks++;
        }
    }
    if(blocks>1){
        printf("Error: %d components",blocks);
        return 0;
    }
    // 若连通，求定点
    for(int i=1;i<=n;i++){
        memset(visit,false,sizeof(visit));
        DFS(i,1);
    }
    int num=0;
    for(int i=1;i<=n;i++){
        if(visit[i]==true)
            num++;
    }
    set<int>::iterator it;
    for(it=best.begin();it!=best.end();it++)
        printf("%d\n",*it);
    return 0;
}

10.4

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;

//PAT A1003
//节点不超过1000个，就用邻接矩阵了
const int MAXN=510;
const int INF=1000000000;
int G[MAXN][MAXN];
bool visit[MAXN];
int rescue[MAXN]; //点权
int num[MAXN]; //最短路径条数
int d[MAXN]; //最短路径
int w[MAXN]; //最大点权之和
int n;

void Dijkstra(int start)
{
    fill(d,d+MAXN,INF);
    memset(num,0,sizeof(num));
    memset(w,0,sizeof(w));
    d[start]=0;
    w[start]=rescue[start];
    num[start]=1;
    for(int i=0;i<n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++){
            if(visit[j]==false&&d[j]<MIN){
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1) return;
        visit[u]=true;
        for(int v=0;v<n;v++){
            if(visit[v]==false&&G[u][v]!=INF){
                if(d[u]+G[u][v]<d[v]){
                    d[v]=d[u]+G[u][v];
                    w[v]=w[u]+rescue[v];
                    num[v]=num[u];
                }
                else if(visit[v]==false&&d[u]+G[u][v]==d[v]){
                    if(w[u]+rescue[v]>w[v]){
                        w[v]=w[u]+rescue[v];
                    }
                    num[v]+=num[u];
                }
            }
        }
    }
}

int main()
{
    fill(G[0],G[0]+MAXN*MAXN,INF);
    int m,c1,c2;
    scanf("%d%d%d%d",&n,&m,&c1,&c2);
    for(int i=0;i<n;i++){
        visit[i]=false;
    }
    int temp1,temp2,temp3;
    for(int i=0;i<n;i++){
        scanf("%d",&temp1);
        rescue[i]=temp1;
    }
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&temp1,&temp2,&temp3);
        G[temp1][temp2]=temp3;
        G[temp2][temp1]=temp3;
    }
    Dijkstra(c1);
    printf("%d %d",num[c2],w[c2]);
    return 0;
}

纯Dijkstra

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;

//PAT A1030
//如果用纯dijkstra的话，思路上上一题一模一样
//唯一的区别就是要开一个pre

const int MAXN=510;
const int INF=1000000000;
int G[MAXN][MAXN];  // 邻接矩阵
bool visit[MAXN]={false};  // 访问情况
int cost[MAXN][MAXN]; //边权
int d[MAXN]; //最短路径
int c[MAXN]; //最大边权之和
int pre[MAXN]; //前一站
int n,m,st,ed;

void Dijkstra(int s)
{
    fill(d,d+MAXN,INF);
    fill(c,c+MAXN,INF);
    for(int i=0;i<n;i++) pre[i]=i;
    d[s]=0;
    c[s]=0;
    for(int i=0;i<n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++){
            if(visit[j]==false&&d[j]<MIN){
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1) return;
        visit[u]=true;
        for(int v=0;v<n;v++){
            if(visit[v]==false&&G[u][v]!=INF){
                if(d[v]>G[u][v]+d[u]){
                   d[v]=G[u][v]+d[u];
                   c[v]=cost[u][v]+c[u];
                   pre[v]=u;
                }
                else if(d[v]==G[u][v]+d[u]){
                    if(c[u]+cost[u][v]<c[v]){
                        c[v]=cost[u][v]+c[u];
                        pre[v]=u;
                    }
                }
            }
        }
    }
}

void DFS(int v)
{
    if(v==st){
        printf("%d ",v);
        return;
    }
    DFS(pre[v]);
    printf("%d ",v);
}

int main()
{
    fill(G[0],G[0]+MAXN*MAXN,INF);
    scanf("%d%d%d%d",&n,&m,&st,&ed);
    int u,v;
    for(int i=0;i<m;i++){
        scanf("%d%d",&u,&v);
        scanf("%d%d",&G[u][v],&cost[u][v]);
        G[v][u]=G[u][v];
        cost[v][u]=cost[u][v];
    }
    Dijkstra(st);
    DFS(ed);
    printf("%d %d",d[ed],c[ed]);
    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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;

//PAT A1018
//读题目都读了一会儿，条件比较复杂

const int MAXN=510;
const int INF=1000000000;
int c,n,s,m;
int G[MAXN][MAXN];  // 邻接矩阵
bool vis[MAXN]={false};  //访问数组
int dot[MAXN]; //点权
int d[MAXN]; //最短路径
vector<int> pre[MAXN]; //前序
vector<int> path,tempath;
int minNeed=INF,minRemain=INF;

void Dijkstra(int s)
{
    fill(d,d+MAXN,INF);
    //fill(cost,cost+MAXN,INF);
    d[s]=0;
    //循环n+1次
    for(int i=0;i<=n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<=n;j++){
            if(vis[j]==false&&d[j]<MIN){
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1) return;
        vis[u]=true;
        for(int v=0;v<=n;v++){
            if(vis[v]==false&&G[u][v]!=INF){
                if(d[u]+G[u][v]<d[v]){
                    d[v]=d[u]+G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if(d[u]+G[u][v]==d[v]){
                    pre[v].push_back(u);
                }
            }
        }
    }
}

void DFS(int v)
{
    if(v==0){
        tempath.push_back(v);
        int need=0,remain=0;
        for(int i=tempath.size()-1;i>=0;i--){
            int id=tempath[i];
            if(dot[id]>0){
                remain+=dot[id];
            }
            else{
                if(remain>abs(dot[id])){
                    remain-=abs(dot[id]);
                }
                else{
                    need+=abs(dot[id])-remain;
                    remain=0;
                }
            }
        }
        if(need<minNeed){
            minNeed=need;
            minRemain=remain;
            path=tempath;
        }
        else if(need==minNeed&&remain<minRemain){
            minRemain=remain;
            path=tempath;
        }
        tempath.pop_back();
        return;
    }
    tempath.push_back(v);
    for(int i=0;i<pre[v].size();i++){
        DFS(pre[v][i]);
    }
    tempath.pop_back();
}

int main()
{
    scanf("%d%d%d%d",&c,&n,&s,&m);
    fill(G[0],G[0]+MAXN*MAXN,INF);
    for(int i=1;i<=n;i++){
        scanf("%d",&dot[i]);
        dot[i]-=c/2;
    }
    int a,b;
    for(int i=0;i<m;i++){
        scanf("%d%d",&a,&b);
        scanf("%d",&G[a][b]);
        G[b][a]=G[a][b];
    }
    // 求最短路径 Dijkstra
    Dijkstra(0);
    //DFS
    DFS(s);
    printf("%d ",minNeed);
    for(int i=path.size()-1;i>=0;i--){
        printf("%d",path[i]);
        if(i>0) printf("->");
    }
    printf(" %d",minRemain);
    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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;
//PAT A1072
//题型是最短路径，条件是cost
//次条件是平均距离
int n,m,k,ds;
const int MAXN=1020;
const int INF=1000000000;
int G[MAXN][MAXN];
int d[MAXN];
bool vis[MAXN]={false};

int getID(char str[])
{
    int i=0,len=strlen(str),ID=0;
    while(i<len){
        if(str[i]!='G'){
            ID=ID*10+(str[i]-'0');
        }
        i++;
    }
    if(str[0]=='G') return n+ID;
    else return ID;
}

void Dijkstra(int s)
{
    memset(vis,0,sizeof(vis));
    fill(d,d+MAXN,INF);
    d[s]=0;
    for(int i=0;i<n+m;i++){
        int u=-1,MIN=INF;
        for(int j=1;j<=m+n;j++){
            if(vis[j]==false&&d[j]<MIN){
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1) return;
        vis[u]=true;
        for(int v=1;v<=n+m;v++){
            if(vis[v]==false&&G[u][v]!=INF){
                if(G[u][v]+d[u]<d[v]){
                    d[v]=d[u]+G[u][v];
                }
            }
        }
    }
}

int main()
{
    scanf("%d%d%d%d",&n,&m,&k,&ds);
    char city1[5],city2[5];
    int u,v,w;
    fill(G[0],G[0]+MAXN*MAXN,INF);
    for(int i=0;i<k;i++){
        scanf("%s %s %d",&city1,city2,&w);
        u=getID(city1);
        v=getID(city2);
        G[u][v]=G[v][u]=w;
    }
    int ansID=-1;
    double ansDis=-1,ansAvg=INF;
    for(int i=n+1;i<=n+m;i++){
        double minDis=INF,avg=0;
        Dijkstra(i);
        for(int j=1;j<=n;j++){
            if(d[j]>ds){
                minDis=-1;
                break;
            }
            if(d[j]<minDis) minDis=d[j];
            avg+=1.0*d[j]/n;
        }
        if(minDis==-1) continue;
        if(minDis>ansDis){
            ansID=i;
            ansDis=minDis;
            ansAvg=avg;
        }
        else if(minDis==ansDis&&avg<ansAvg){
            ansID=i;
            ansAvg=avg;
        }
    }
    if(ansID==-1) printf("No Solution\n");
    else{
        printf("G%d\n",ansID-n);
        printf("%.1f %.1f\n",ansDis,ansAvg);
    }
    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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>

using namespace std;
//PAT A1087
//cost + happiness + ave_cost
const int MAXN=220;
const int INF=1000000000;
int n,k;
char ed[5];
map<string,int> strToInt;
map<int,string> intToStr;
int G[MAXN][MAXN];
int hap[MAXN];
int d[MAXN];
vector<int> pre[MAXN];
vector<int> tempath,path;
int numPath=0,maxH=0;
double aveH=0;
bool vis[MAXN]={false};

void Dijkstra(int s)
{
    fill(d,d+MAXN,INF);
    d[s]=0;
    for(int i=0;i<n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<MIN){
                MIN=d[j];
                u=j;
            }
        }
        if(u==-1) return;
        vis[u]=true;
        for(int v=0;v<n;v++){
            if(vis[v]==false&&G[u][v]!=INF){
                if(G[u][v]+d[u]<d[v]){
                    d[v]=d[u]+G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if(G[u][v]+d[u]==d[v]){
                    pre[v].push_back(u);
                }
            }
        }
     }
}

void DFS(int v)
{
    if(v==0){
        tempath.push_back(0);
        numPath++;
        int tempW=0;
        for(int i=tempath.size()-2;i>=0;i--){
            int id=tempath[i];
            tempW+=hap[id];
        }
        double tempA=1.0*tempW/(tempath.size()-1);
        if(tempW>maxH){
            maxH=tempW;
            aveH=tempA;
            path=tempath;
        }
        else if(tempW==maxH&&tempA>aveH){
            path=tempath;
            aveH=tempA;
        }
        tempath.pop_back();
        return;
    }
    tempath.push_back(v);
    for(int i=0;i<pre[v].size();i++){
        DFS(pre[v][i]);
    }
    tempath.pop_back();
}

int main()
{
    scanf("%d %d %s",&n,&k,ed);
    fill(G[0],G[0]+MAXN*MAXN,INF);
    strToInt[ed]=0;
    intToStr[0]=ed;
    char temp1[5],temp2[5];
    int ha;
    for(int i=1;i<n;i++){
        scanf("%s %d",temp1,&ha);
        strToInt[temp1]=i;
        intToStr[i]=temp1;
        hap[i]=ha;
    }
    for(int i=0;i<k;i++){
        scanf("%s %s %d",temp1,temp2,&ha);
        int a,b;
        a=strToInt[temp1];
        b=strToInt[temp2];
        G[a][b]=G[b][a]=ha;
    }
    Dijkstra(0);
    int rom=strToInt["ROM"];
    DFS(rom);
    printf("%d %d %d %d\n",numPath,d[rom],maxH,(int)aveH);
    for(int i=path.size()-1;i>=0;i--){
        cout<<intToStr[path[i]];
        if(i>0) printf("->");
    }
    return 0;
}

本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2020/02/24/%E7%AE%97%E6%B3%95%E7%AC%94%E8%AE%B0-%E7%AC%AC%E5%8D%81%E7%AB%A0/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 本站访客数人

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>希望未来的xiaoyuyu<br>可以成为优秀的工程师