无知 无求

0%

发表于 分类于 ，

F种食物 D种饮料 每个人只需要一份食物和一份饮料 但每个人都有自己的喜好 问你当前的储备最多能满足多少人的需求

一开始读错题意了…不是需要给每个人提供所有喜欢的食物或者饮料 只要某一种提供一份就够了 这就变成很基础的网络流了…

源点连食物 容量就是食物容量 饮料连汇点 容量是饮料容量 食物连人如果这个人喜欢 人连饮料一样是如果喜欢 这些容量都是1 最大流即可

我这里把人习惯性的拆开来了…实际上不拆似乎也可以?对不起想错了 为了限制每个人只花费一份必须拆

ac代码

++
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
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;
const int MAXV = 2005;
const int INF = 1<<30;
struct Edge{ int to, cap, rev; };
std::vector<Edge> G[MAXV];
int level[MAXV];
int iter[MAXV]; //当前弧，之前的已经没有用了

void addedge(int from, int to, int cap) {
    G[from].push_back(Edge{to, cap, G[to].size()});
    G[to].push_back(Edge{from, 0, G[from].size()-1});
}

void bfs(int s) {
    memset(level, -1, sizeof level);
    std::queue<int> que;
    level[s] = 0;
    que.push(s);
    while (!que.empty()) {
        int v = que.front(); que.pop();
        for (int i = 0; i < G[v].size(); ++i) {
            Edge &e = G[v][i];
            if (e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v, int t, int f) {
    if (v == t) return f;
    for (int &i = iter[v]; i < G[v].size(); ++i) { // 注意i是引用 实现当前弧优化
        Edge &e = G[v][i];
        if (e.cap > 0 && level[v] < level[e.to]) {
            int d = dfs(e.to, t, std::min(f, e.cap));
            if (d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int maxflow(int s, int t) {
    int flow = 0;
    for (; ;) {
        bfs(s);
        if (level[t] < 0) return flow;
        memset(iter, 0, sizeof iter);
        int f;
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
    return flow;
}
int main()
{
    int N,F,D;
    while(~scanf("%d%d%d",&N,&F,&D))
    {
        for(int i=0;i<(N*2+F+D+2);++i)
        {
            G[i].clear();
        }
        int start=N*2+F+D,end=start+1;
        for(int i=0;i<F;++i)
        {
            int tmp;
            scanf("%d",&tmp);
            addedge(start,N*2+i,tmp);
        }
        for(int i=0;i<D;++i)
        {
            int tmp;
            scanf("%d",&tmp);
            addedge(N*2+F+i,end,tmp);
        }
        char sta[220];
        for(int i=0;i<N;++i)
        {
            scanf("%s",sta);
            for(int j=0;j<F;++j)
            {
                if(sta[j]=='Y')
                {
                    addedge(N*2+j,i*2,1);
                }
            }
            addedge(i*2,i*2+1,1);
        }
        for(int i=0;i<N;++i)
        {
            scanf("%s",sta);
            for(int j=0;j<D;++j)
            {
                if(sta[j]=='Y')
                {
                    addedge(i*2+1,N*2+F+j,1);
                }
            }
        }
        int ans=maxflow(start,end);
        printf("%d\n",ans);
    }
    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
class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        vector<int> *num1=&nums1,*num2=&nums2;
        if(nums1.size()>nums2.size()){
            swap(num1,num2);
        }
        vector<int> &A=*num1,&B=*num2;
        int m=num1->size(),n=num2->size();
        int iMin=0,iMax=m,halflen=(m+n+1)/2;
        while(iMin<=iMax){
            int i=(iMin+iMax)/2;
            int j=halflen-i;
            if(i<iMax&&B[j-1]>A[i]){
                iMin=i+1;
            }else if(i>iMin&&A[i-1]>B[j]){
                iMax=i-1;
            }else{
                int maxLeft = 0;
                if (i == 0) { maxLeft = B[j-1]; }
                else if (j == 0) { maxLeft = A[i-1]; }
                else { maxLeft = max(A[i-1], B[j-1]); }
                if ( (m + n) % 2 ) { return maxLeft; }

                int minRight = 0;
                if (i == m) { minRight = B[j]; }
                else if (j == n) { minRight = A[i]; }
                else { minRight = min(B[j], A[i]); }
                double tmp=maxLeft+minRight;
                return tmp/ 2.0;
            }
        }
        return 0;
    }
};

发表于 分类于 ，

本来读完题面以为是简单的网络流模板题…只是疑惑了一下为什么点的范围…这么大…然后发现常用的网络流板子过不去…
本来以为是vector初始化太慢了我强行改成手动管理..依旧t了

后来查了题解才明白这是需要另外一种算法…sap算法来优化网络流问题…过题的代码基本是按照题解来的就没啥可放的了…

超时代码

++
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include <cstdio>
#include <vector>
#include <cstring>
#include<algorithm>
#include <queue>
using namespace std;
const int MAXV = 100050;
const int maxm=100050;
const int INF = 1<<30;
int edge;
// struct Edge{ int to, cap, rev; };
// std::vector<Edge> G[MAXV];
int level[MAXV];
int iter[MAXV]; //当前弧，之前的已经没有用了
int head[MAXV];
struct edgenode
{
    int to;//边的指向
    int cap;//边的容量
    int next;//链表的下一条边
} edges[maxm];
void init()
{
    edge=0;
    memset(head,-1,sizeof(head));
}
void addedge(int from, int to, int cap) {
    edges[edge].cap=cap;
    edges[edge].to=to;
    edges[edge].next=head[from];
    head[from]=edge++;
    edges[edge].cap=0;
    edges[edge].to=from;
    edges[edge].next=head[to];
    head[to]=edge++;
    // G[from].push_back(Edge{to, cap, G[to].size()});
    // G[to].push_back(Edge{from, 0, G[from].size()-1});
}

void bfs(int s) {
    memset(level, -1, sizeof level);
    std::queue<int> que;
    level[s] = 0;
    que.push(s);
    while (!que.empty()) {
        int v = que.front(); que.pop();
        // for (int i = 0; i < G[v].size(); ++i) {
        //     Edge &e = G[v][i];
        //     if (e.cap > 0 && level[e.to] < 0) {
        //         level[e.to] = level[v] + 1;
        //         que.push(e.to);
        //     }
        // }
        for (int i = head[v]; i !=-1; i=edges[i].next) {
            edgenode &e = edges[i];
            if (e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v, int t, int f) {
    if (v == t) return f;
    // for (int &i = iter[v]; i < G[v].size(); ++i) { // 注意i是引用 实现当前弧优化
    //     Edge &e = G[v][i];
    //     if (e.cap > 0 && level[v] < level[e.to]) {
    //         int d = dfs(e.to, t, std::min(f, e.cap));
    //         if (d > 0) {
    //             e.cap -= d;
    //             G[e.to][e.rev].cap += d;
    //             return d;
    //         }
    //     }
    // }
    if(iter[v]==0)
    {
        iter[v]=head[v];
    }
    for (int &i = iter[v]; i !=-1; i=edges[i].next) { // 注意i是引用 实现当前弧优化
        edgenode &e = edges[i];
        if (e.cap > 0 && level[v] < level[e.to]) {
            int d = dfs(e.to, t, std::min(f, e.cap));
            if (d > 0) {
                e.cap -= d;
                edges[i^1].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int maxflow(int s, int t) {
    int flow = 0;
    for (; ;) {
        bfs(s);
        if (level[t] < 0) return flow;
        memset(iter, 0, sizeof iter);
        int f;
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
    return flow;
}
struct island
{
    int x,pos;
};
bool cmp(island a,island b)
{
    return a.x<b.x;
}
island lands[100030];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int N,M;
        scanf("%d%d",&N,&M);
        // for(int i=0;i<=N;++i)
        // {
        //     G[i].clear();
        // }
        init();
        for(int i=0;i<N;++i)
        {
            int x,y;
            scanf("%d%d",&lands[i].x,&y);
            lands[i].pos=i+1;
        }
        sort(lands,lands+N,cmp);
        for(int i=0;i<M;++i)
        {
            int u,v,t;
            scanf("%d%d%d",&u,&v,&t);
            addedge(u,v,t);
            addedge(v,u,t);
        }
        int res=maxflow(lands[0].pos,lands[N-1].pos);
        printf("%d\n",res);
    }
    return 0;
}

发表于 更新于 分类于 ，

既然是子串…我第一个想到的就是简单尺取法了…过一遍O(n)的性能…简单写了写也就ac了

过了以后发现这种经典问题有更简单的思路…当看到重复的时候其实以及可以知道到重复位置以前的最长长度已知…可以直接跳到重复字符的下一位置…

我的代码如下

++
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
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int start=0,end=0,maxans=0,tmpans=0;
        bool check[256];
        memset(check,0,sizeof(check));
        while(end<s.length())
        {
            if(check[s[end]])
            {
                check[s[start]]=false;
                ++start;
                --tmpans;
            }
            else
            {
                check[s[end]]=true;
                ++end;
                ++tmpans;
                maxans=max(maxans,tmpans);
            }
        }
        return maxans;
    }
};

发表于 分类于 ，

简单的网络流问题 p个产电 c个费电 m条边 多源点多汇点问题 增加超级源点和超级汇点 超级源点向产电连边值即为产电值
费电单位向超级汇点连边值即为费电值 其余m条边直接相连即可 跑一下最大流就是结果了。。。

AC代码

++
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
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;
const int MAXV = 2005;
const int INF = 1<<30;
struct Edge{ int to, cap, rev; };
std::vector<Edge> G[MAXV];
int level[MAXV];
int iter[MAXV]; //当前弧，之前的已经没有用了

void addedge(int from, int to, int cap) {
    G[from].push_back(Edge{to, cap, G[to].size()});
    G[to].push_back(Edge{from, 0, G[from].size()-1});
}

void bfs(int s) {
    memset(level, -1, sizeof level);
    std::queue<int> que;
    level[s] = 0;
    que.push(s);
    while (!que.empty()) {
        int v = que.front(); que.pop();
        for (int i = 0; i < G[v].size(); ++i) {
            Edge &e = G[v][i];
            if (e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v, int t, int f) {
    if (v == t) return f;
    for (int &i = iter[v]; i < G[v].size(); ++i) { // 注意i是引用 实现当前弧优化
        Edge &e = G[v][i];
        if (e.cap > 0 && level[v] < level[e.to]) {
            int d = dfs(e.to, t, std::min(f, e.cap));
            if (d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int maxflow(int s, int t) {
    int flow = 0;
    for (; ;) {
        bfs(s);
        if (level[t] < 0) return flow;
        memset(iter, 0, sizeof iter);
        int f;
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
    return flow;
}
int main()
{
    int n,p,c,t;
    while(~scanf("%d%d%d%d",&n,&p,&c,&t))
    {
        for(int i=0;i<=n+1;++i)
        {
            G[i].clear();
        }
        for(int i=0;i<t;++i)
        {
            int u,v,val;
            scanf(" (%d,%d)%d",&u,&v,&val);
            addedge(u,v,val);
        }
        for(int i=0;i<p;++i)
        {
            int u,val;
            scanf(" (%d)%d",&u,&val);
            addedge(n,u,val);
        }
        for(int i=0;i<c;++i)
        {
            int u,val;
            scanf(" (%d)%d",&u,&val);
            addedge(u,n+1,val);
        }
        int res=maxflow(n,n+1);
        printf("%d\n",res);
    }
    return 0;
}

发表于 分类于 ，

除了做做ACM的题，也会没事刷刷leetcode的题感受一下 这里主要是对比自己的写法与其他人更好的写法之间的差异 后面有可能会尝试其他语言来完成题目？

题目意思清晰直白 只存储某位的链表逆序相加得到新链表

写的时候才会考虑到很多细节问题 进位是最容易想到的问题 还有两个链表长度不一致的问题 以及最后提交才发现的可能存在单纯由于进位导致长度增加的问题

刷leetcode感觉就是算法层面的并不是特别复杂 工业应用的也往往是这种简单的逻辑 但要考虑到种种细节…细桀(

代码如下

++
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
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        bool over=false;
        ListNode *res=NULL,*cur=NULL;
        if((l1->val+l2->val)>=10){
            over=true;
        }
        cur=res=new ListNode((l1->val+l2->val)%10);
        l1=l1->next,l2=l2->next;
        while(l1!=NULL&&l2!=NULL){
            int addtemp=l1->val+l2->val+over;
            ListNode *tmp=new ListNode(addtemp%10);
            if(addtemp>=10){
                over=true;
            }
            else{
                over=false;
            }
            cur->next=tmp;
            cur=tmp;
            l1=l1->next;
            l2=l2->next;
        }
        ListNode *left=(l1==NULL)?l2:l1;
        while(left!=NULL)
        {
            int addtemp=left->val+over;
            ListNode *tmp=new ListNode(addtemp%10);
            if(addtemp>=10)
            {
                over=true;
            }else{
                over=false;
            }
            cur->next=tmp;
            cur=tmp;
            left=left->next;
        }
        if(over)
        {
            ListNode *tmp=new ListNode(1);
            cur->next=tmp;
        }
        return res;
    }
};

发表于 分类于 ，

好长时间没更新了哈…前段时间有点忙 后面没事的时候开始更新写写题

很长时间没读英文题面了还有点不适应…题目大意是有n个店员m个仓库k种商品
每个店员需求不同的商品，从不同的仓库调花费也各不相同，问可能的调度中花费最小的，没有则-1

感觉是很普遍的费用流例题，不过也是好长时间不写了…

给了费用矩阵肯定是k种商品每种的n和m之间的全连接写花费，同时为了限制流量店员和仓库都要拆成两个点之间的边就是仓库的容量限制或者店员的商品需求

仔细想了一下发现不太会判断最小费用流的最大流是否满足需求，后来想想可以用限制店员的边来看是否达到要求

写的时候意识到其实不需要拆点，每种商品对应的仓库和店员是分开的已经可以达成要求了

第一遍把所有商品一块计算…tle 后来参考了一下其他人的做法 每个商品分别作为一个小图来计算…会快很多

AC代码

++
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
#include <cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
 
const int oo=1e9;//无穷大
const int maxm=200020;//边的最大数量，为原图的两倍
const int maxn=5040;//点的最大数量
 
int node,src,dest,edge;//node节点数，src源点，dest汇点，edge边数
int head[maxn],p[maxn],dis[maxn],q[maxn],vis[maxn];//head链表头，p记录可行流上节点对应的反向边，dis计算距离
 
struct edgenode
{
    int to;//边的指向
    int flow;//边的容量
    int cost;//边的费用
    int next;//链表的下一条边
} edges[maxm];
 
void prepare(int _node,int _src,int _dest);
void addedge(int u,int v,int f,int c);
bool spfa();

 
inline void prepare(int _node,int _src,int _dest)
{
    node=_node;
    src=_src;
    dest=_dest;
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    memset(p,0,sizeof(p));
    memset(q,0,sizeof(q));
    memset(dis,0,sizeof(dis));
    edge=0;
}
 
void addedge(int u,int v,int f,int c)
{
    edges[edge].flow=f;
    edges[edge].cost=c;
    edges[edge].to=v;
    edges[edge].next=head[u];
    head[u]=edge++;
    edges[edge].flow=0;
    edges[edge].cost=-c;
    edges[edge].to=u;
    edges[edge].next=head[v];
    head[v]=edge++;
}
 
bool spfa()
{
    int i,u,v,l,r=0,tmp;
    for (i=0; i<node; i++) dis[i]=oo;
    dis[q[r++]=src]=0;
    p[src]=p[dest]=-1;
    for (l=0; l!=r; ((++l>=maxn)?l=0:1))
    {
        for (i=head[u=q[l]],vis[u]=false; i!=-1; i=edges[i].next)
        {
            if (edges[i].flow&&dis[v=edges[i].to]>(tmp=dis[u]+edges[i].cost))
            {
                dis[v]=tmp;
                p[v]=i^1;
                if (vis[v]) continue;
                vis[q[r++]=v]=true;
                if (r>=maxn) r=0;
            }
        }
    }
    return p[dest]>=0;
}
 
int spfaflow()
{
    int i,ret=0,delta;
    while (spfa())
    {
        //按记录原路返回求流量
 
        for (i=p[dest],delta=oo; i>=0; i=p[edges[i].to])
        {
            delta=min(delta,edges[i^1].flow);
        }
        for (int i=p[dest]; i>=0; i=p[edges[i].to])
        {
            edges[i].flow+=delta;
            edges[i^1].flow-=delta;
        }
        ret+=delta*dis[dest];
    }
    return ret;
}
int shoper[100][100];
int castle[100][100];
int need[120];
int have[120];
int main()
{
    int N,M,K,start,end;
    while(scanf("%d%d%d",&N,&M,&K),N+M+K)
    {
        memset(shoper,0,sizeof(shoper));
        memset(castle,0,sizeof(castle));
        memset(need,0,sizeof(need));
        memset(have,0,sizeof(have));
        for(int i=1;i<=N;++i)
        {
            for(int j=0;j<K;++j)
            {
                int tmp;
                scanf("%d",&tmp);
                shoper[j][i]=tmp;
                need[j]+=tmp;
            }
        }
        for(int i=1;i<=M;++i)
        {
            for(int j=0;j<K;++j)
            {
                int tmp;
                scanf("%d",&tmp);
                castle[j][i]=tmp;
                have[j]+=tmp;
            }
        }
        int ans=0;
        bool achieve=true;
        for(int i=0;i<K;++i)
        {
            if(need[i]>have[i])
            {
                achieve=false;
            }
            int start=0,end=(N+M)+1;
            prepare(end+1,start,end);
            for(int j=1;j<=N;++j)
            {
                if(shoper[i][j]!=0)
                {
                    addedge(j,end,shoper[i][j],0); 
                }
            }
            for(int j=1;j<=M;++j)
            {
                if(castle[i][j]!=0)
                {
                    addedge(start,N+j,castle[i][j],0);
                }
            }
            for(int j=1;j<=N;++j)
            {
                for(int t=1;t<=M;++t)
                {
                    int tmp;
                    scanf("%d",&tmp);
                    addedge(N+t,j,oo,tmp);
                }
            }
            if(!achieve)
            {
                continue;
            }
            ans+=spfaflow();
        }
        if(!achieve)
        {
            printf("-1\n");
        }
        else
        {
            printf("%d\n",ans);
        }
    }
    return 0;
}

发表于 分类于 ，

那我们就算正式开始尝试了，为了有一个开头，我翻了一下youtube发现还是有相关教程的，所以前期的几篇大概会通过看教程模仿再加入一些自己的改进

有用的资源

这里建议在看教程模仿的时候调用的方法都去api文档里查一查，一是能够更加熟悉函数，二是教程不可避免地有些老了，有的方法已经被更换建议按照api中的新接口来使用。比如查看携带的资源现在统一为一个store对象了

写下这篇文章的时候我看完了教程的前六段，首先类似地，我们将creep分成了几类，harvester，upgrader，builder，repairer，它们分别做的事情也非常显然

  • harvester是最基本的收获能量填给spawn（以及建造了extension之后填给所有需要energy的地方）
  • upgrader负责收集能量后升级房间的controller
  • builder负责收集能量后填向需要建设的工地
  • repairer负责收集能量后维修建筑

目前的逻辑有的几个问题

  • 当前最基本的逻辑并没有实现自动建设工地，所以目前还需要我们手动指定工地
  • 所有的creep都是从房间的能源生成地获取能量后去做自己的事情，在RCL高了之后我们可以建设storge、link等让harvester填给存储设施而其他的creep从存储设施获取
  • repairer目前的逻辑是先维修不是WALL的建筑之后如果有WALL再维修，这里有一个坑WALL是不能被FIND_MY_STRUCTURE搜索到的，必须是FIND_STRUCTURE才能找到WALL

与教程不同的是，由于存在creep发现自己的事情已经做完的情况下可以去做其他creep的工作，但是直接引用会导致很大的重复代码运行，所以我加入了rolehandle模块负责统一处理各种creep共同的问题而将每种creep的role精简了许多

rolehandler
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
var roleharvester=require('./roleharvester');
var roleupgrader=require('./roleupgrader');
var rolebuilder=require('./rolebuilder');
var rolerepairer=require('./rolerepairer');
module.exports ={
    run:function(creep){
        if(creep.memory.working == true && creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
            creep.memory.working = false;
        }
        else if(creep.memory.working == false && creep.store[RESOURCE_ENERGY] == 0){
            creep.memory.working = true;
        }
        var isworking = creep.memory.working;
        if(creep.memory.role == 'harvester'){
            if(isworking){
                roleharvester.prepare(creep);
            }
            else{
                roleharvester.run(creep);
            }
        }
        else if (creep.memory.role == 'upgrader'){
            if(isworking){
                roleupgrader.prepare(creep);
            }
            else{
                roleupgrader.run(creep);
            }
        }
        else if (creep.memory.role == 'builder'){
            if(isworking){
                rolebuilder.prepare(creep);
            }
            else{
                rolebuilder.run(creep);
            }
        }
        else if (creep.memory.role == 'repairer'){
            if(isworking){
                rolerepairer.prepare(creep);
            }
            else{
                rolerepairer.run(creep);
            }
        }
    }
};
rolerepairer
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
var rolebuilder=require('./rolebuilder');
module.exports = {
    run:function(creep){
        var structure=creep.pos.findClosestByPath(FIND_MY_STRUCTURES,{
            filter:(s)=>s.hits<s.hitsMax && s.structureType != STRUCTURE_WALL
        });
        if(structure!=undefined){
            if(creep.repair(structure)==ERR_NOT_IN_RANGE){
                creep.moveTo(structure);
            }
        }
        else{
            structure=creep.pos.findClosestByPath(FIND_STRUCTURES,{
                filter:(s)=> s.structureType == STRUCTURE_WALL && s.hits<s.hitsMax 
            });
            if(structure!=undefined){
                if(creep.repair(structure)==ERR_NOT_IN_RANGE){
                    creep.moveTo(structure);
                }
            }
            else{
                rolebuilder.run(creep);
            }
        }
    },
    prepare:function(creep){
        var source=creep.pos.findClosestByPath(FIND_SOURCES);
        if(creep.harvest(source)==ERR_NOT_IN_RANGE)
        {
            creep.moveTo(source);
        }
    }
};

另外一段处理就是spwan的处理了，当前的处理很简单，当spawn能量够时看缺乏哪种creep按需生产即可

下一步的计划首先是根据RCL以及当前拥有的能量生产适当的creep，尽量做到能够根据RCL情况以及实际能量来生产，而后可能的话开始尝试实现一些简单的自动建筑？

发表于 更新于 分类于 ，

很明显，作为一个作业爆多的计算机专业学生日渐秃头者，我们不希望被别人发现我们在打游戏，需要一个客户端是一件很不自然的事情，所以我们需要配置vscode的开发环境——无需客户端的那种

看起来我在写码 其实我在打游戏 惊喜吧╮(￣▽￣)╭

当然又是有现成的教程啦

一样有很多问题…插件安装会自动卸载一堆东西…似乎是npm的锅…卸载的东西重新安一次screep就回来了…

本地远程终端连接需要不暂停才能正常看…它的插件watch需要你手动放到代码里才能正常启用…

设好grunt检测代码变化上传之后，要注意私服的设置要加一些东西…具体的可以看这里
当然顺便把代码仓库传GitHub上…

搞定收工

发表于 更新于 分类于 ，

中文文档真的是好用嗷

编程游戏，对我胃口嗷

为了能够在世界服里有一个比较好的开端，我打算先在自己的服务器上跑私有客户端（感谢阿里云学生服务器），在服务器上做一个比较完善的尝试后再上世界服

按照文档说的方法

装好一系列的环境 node.js MongoDB Redis…

注意 文档里给的node.js版本也还是过低了…后来发现npm里有一个模块n可以来管理版本，直接搜就能看到了不难

1
2
3
sudo apt install npm
sudo npm install n -g
n stable

其他包倒是问题不大，照着教程来就是了
唔..有点尴尬…阿里云给的学生服务器性能不太够的样子…考虑一下要怎么办吧…

尝试了一下…我去掉了额外的mongodb redis…能跑起来了…发现自己对于它cli和服务器的机制理解有问题…不知道是因为减少安装的包还是改正了使用过程的结果…反正能用了

可是累死我了…