【FJOI2014-1】游记/题解

FJOI2014-1 “FJ为提高考试有效度 良心出题 成功保证所有人分数都不低于中位数”
我就是中位数啊XD 大家好啊~
WC刚被虐完就去了fz
各种颓废键盘基本没动的度过了两天(ban’nian)= =
考试的时候自然得hh
开考看题 第一题 想了20+min基本想出了正解
第二题 妈蛋 这不是昨天讲的原题?=-=
第三题 奇怪的几何 感觉20分说不定枚举中线什么的还是可以拿的233
//此时≈8:30 估分220
先pa第三题骗分 试了任意两点中点连线 中垂线 直接连线等各种奇怪的方法依然过不了= =
去上了个厕所决定不管这题了=-=
//此时≈9:20 估分200
第二题稍微回忆了下昨天讲课的东西 就开始敲
半个多小时后敲完了 发现样例过不了 手画了画 发现题目看错了XD
已经过去一半时间了 有点虚了=-=
想了十几分钟的正解 想的比较乱 也就没想出来
直接怒pa暴力磙粗=-=
//此时≈10:20 估分130
剩下第一题 奇怪的求树+树分治
树分治我就没打过几遍啊 但是感觉pa的出来于是就开始。。
一个多小时过去了//我考试的时候树分治写的不能更hh 300+行不能多说
写完了 调调样例 错了 改了改 过了 随便改了个数据 错了。。再也没有改出来QvQ
//此时12:00 估分30
中午略=-=
下午看成绩 第二题暴力全崩
//此时14:30 分数:0
【再见】

=第一题=
先求一个最短路图 然后再这个图上dfs 对于一个点的所有出点 按编号从小到大dfs
这样可以保证dfs树就是题目要求的树
然后在这棵树上跑树分治 f[i][j][2]表示前i棵子树 从根出发链长为j [0:最长长度][1:这个长度条件下的方案数]
对于第i+1棵子树 单独跑一个f'[i][j][2]意义一样 枚举这颗子树上链长 和f一起更新答案 然后用f‘更新f

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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <string>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <vector>
#include <functional>
#include <ctime>
#include <cstdlib>
#include <sstream>
#include <set>
#include <deque>
using namespace std;
typedef long long ll;
typedef long double ld;

const int maxn = 30005;

struct line
{
    int to, next, v;
};

struct lin
{
    line li[200005];
    int be_[maxn], l;

    int be(int i) { return be_[i]; }
    int v(int i) { return li[i].v; }
    int to(int i) { return li[i].to; }
    int next(int i) { return li[i].next; }

    void makeline(int fr, int to, int v)
    {
        ++l;
        li[l].next = be_[fr];
        be_[fr] = l;
        li[l].to = to;
        li[l].v = v;
    }
}L1, L2;

queue<int> q;
stack<int> s;

int fa[maxn], n, m, k, f[maxn], g[maxn], d[maxn], fun[maxn][3], fun2[maxn][3], tot, tot2, tot1, b[maxn], dist[maxn], ans1, ans2, is[maxn], tb[maxn];
vector<pair<int, int> > v[maxn];

bool cmp(pair<int, int> a, pair<int, int> b)
{
    return a.first > b.first;
}

void spfa()
{
    memset(dist, 0x3f, sizeof(dist));
    for (q.push(1), b[1] = 1, dist[1] = 0; !q.empty();)
    {
        int now = q.front();
        q.pop();
        for (int i = L1.be(now); i; i = L1.next(i))
        {
            int to = L1.to(i);
            if (dist[to] <= dist[now] + L1.v(i)) continue;
            dist[to] = dist[now] + L1.v(i);
            if (!b[to])
            {
                b[to] = 1;
                q.push(to);
            }
        }
        b[now] = 0;
    }
}

void get_dfs(int now)
{
    for (int i = L1.be(now); i; i = L1.next(i))
    {
        int to = L1.to(i);
        if (b[to] || dist[to] != dist[now] + L1.v(i)) continue;
        b[to] = 1;
        L2.makeline(now, to, L1.v(i));
        L2.makeline(to, now, L1.v(i));
        get_dfs(to);
    }
}

int get_center(int now)
{
    int tot = 0;
    for (q.push(now), b[now] = 1; !q.empty();)
    {
        int now = q.front();
        q.pop();
        f[now] = g[now] = 0;
        s.push(now);
        ++tot;
        for (int i = L2.be(now); i; i = L2.next(i))
        {
            int to = L2.to(i);
            if (b[to] || is[to]) continue;
            fa[to] = now;
            b[to] = 1;
            q.push(to);
        }
    }
    int ret = -1;
    for (; !s.empty();)
    {
        int now = s.top();
        s.pop();
        b[now] = 0;
        f[fa[now]] += ++f[now];
        g[fa[now]] = max(g[fa[now]], f[now]);
        g[now] = max(g[now], tot - f[now]);
        if (ret == -1 || g[now] < g[ret])
            ret = now;
    }
    return ret;
}

void re(int &a, int &b, int c, int d)
{
    if (d == 0) return;
    if (a < c) a = c, b = d;
    else if (a == c) b += d;
}

void calc(int now)
{
    ++tot, ++tot1;
    fun[0][0] = tot1, fun[0][1] = 0, fun[0][2] = 1;
    int tans1 = 0, tans2 = 0;
    d[now] = 0;

    for (int p = L2.be(now); p; p = L2.next(p))
    {
        int now = L2.to(p);
        if (is[now]) continue;
        ++tot2;
        fun2[1][0] = tot2, fun2[1][1] = L2.v(p), fun2[1][2] = 1;
        for (q.push(now), b[now] = tot, d[now] = 1, dist[now] = L2.v(p); !q.empty();)
        {
            int now = q.front();
            q.pop();
            for (int i = L2.be(now); i; i = L2.next(i))
            {
                int to = L2.to(i);
                if (is[to] || b[to] == tot) continue;
                b[to] = tot;
                d[to] = d[now] + 1;
                dist[to] = dist[now] + L2.v(i);
                if (fun2[d[to]][0] != tot2)
                    fun2[d[to]][0] = tot2, fun2[d[to]][1] = dist[to], fun2[d[to]][2] = 1;
                else
                    re(fun2[d[to]][1], fun2[d[to]][2], dist[to], 1);
                q.push(to);
            }
        }
       
        for (int i = 1; i <= k; ++i)
        {
            if (fun2[i][0] != tot2) break;
            if (fun[k - i - 1][0] != tot1) continue;
            re(tans1, tans2, fun2[i][1] + fun[k - i - 1][1], fun2[i][2] * fun[k - i - 1][2]);
        }
       
        for (int i = 1; i <= k; ++i)
        {
            if (fun2[i][0] != tot2) break;
            if (fun[i][0] != tot1)
                fun[i][0] = tot1, fun[i][1] = fun2[i][1], fun[i][2] = fun2[i][2];
            else
                re(fun[i][1], fun[i][2], fun2[i][1], fun2[i][2]);
        }
    }
    re(ans1, ans2, tans1, tans2);
}

void solve(int now)
{
    int center = get_center(now);
    is[center] = 1;
    calc(center);
    for (int i = L2.be(center); i; i = L2.next(i))
    {
        int to = L2.to(i);
        if (is[to]) continue;
        solve(to);
    }
}

int main()
{
    freopen("input.in", "r", stdin);
    freopen("output.out", "w", stdout);
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 0; i < m; ++i)
    {
        int fr, to, vv;
        scanf("%d%d%d", &fr, &to, &vv);
        v[fr].push_back(make_pair(to, vv));
        v[to].push_back(make_pair(fr, vv));
    }
    for (int i = 1; i <= n; ++i)
    {
        sort(v[i].begin(), v[i].end(), cmp);
        for (int j = 0; j < v[i].size(); ++j)
            L1.makeline(i, v[i][j].first, v[i][j].second);
    }
    spfa();
    b[1] = 1;
    get_dfs(1);
    ans1 = ans2 = 0;
    memset(b, 0, sizeof(b));
    solve(1);
    printf("%d %d", ans1, ans2);
    fclose(stdin);fclose(stdout);
}

=第二题=
首先对于两个重心的情况 可以在中间加一个点 变为一个重心的情况 记住答案-1
树形dp
f[i][j]表示以i为根的子树 大小为j的方案数
转移可以用背包把一个根的所有子树合并
计算f数组复杂度O(n^3)
然后对于根 求
g[i][j][k]表示 前i棵子树 最大节点数<=j 节点数和为k的方案数 更新用背包更新 直接枚举当前子树取多少 前面的一共取多少什么的 如果直接这样做 复杂度是O(n^4)的 可以把根的所有子树按size从小到大排序 这样就可以保证对于i j只要枚举O(第i棵子树大小) 即共为Σ(size[i])=n 降了一维 然后枚举最大的子树的大小 设为k 可以证明只要满足总节点数>k*2则这个根为唯一重心、
这里g数组的第二维表示的是最大节点数不超过j的方案数
可以用g[][j][] – g[][j – 1][]则可以表示最大节点数位j的方案数
即ans=Σ(g[m][k][k * 2] – g[m][k – 1][k * 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
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
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <string>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <vector>
#include <functional>
#include <ctime>
#include <cstdlib>
#include <sstream>
#include <set>
#include <deque>
using namespace std;
typedef long long ll;
typedef long double ld;

const int inf = 10007;

struct line
{
    int next, to;
}li[1005];

int f[205][205], be[205], l, n, m, mx[205], t[205][2], tot, g[205][205][205];
vector<int> v[205], ve;

void re(int i, int v)
{
    if (t[i][0] != tot)
        t[i][0] = tot, t[i][1] = v;
    else
        t[i][1] = (t[i][1] + v) % inf;
}

int dp(int now, int last)
{
    int sum = 1;
    f[now][0] = f[now][1] = 1;
    for (int i = be[now]; i; i = li[i].next)
    {
        int to = li[i].to;
        if (to == last) continue;
        int tp = dp(to, now);
        ++tot;
        for (int j = 1; j <= tp; ++j)
            for (int k = 1; k <= sum; ++k)
                re(j + k, f[to][j] * f[now][k] % inf);

        for (int k = 1; k <= sum + tp; ++k)
            if (t[k][0] == tot)
                f[now][k] = (f[now][k] + t[k][1]) % inf;
        sum += tp;
    }
    return mx[now] = sum;
}

bool cmp(int a, int b)
{
    return mx[a] < mx[b];
}

void makeline(int fr, int to)
{
    ++l;
    li[l].next = be[fr];
    be[fr] = l;
    li[l].to = to;
}

int dfs(int now, int last)
{
    int ans = 1;
    for (int i = 0; i < v[now].size(); ++i)
        if (v[now][i] != last)
            ans += dfs(v[now][i], now);
    return ans;
}

int main()
{
    freopen("input.in", "r", stdin);
    freopen("output.out", "w", stdout);
    int test, te = 0;
    scanf("%d", &test);
    while (test--)
    {
        memset(f, 0, sizeof(f));
        memset(be, 0, sizeof(be));
        memset(mx, 0, sizeof(mx));
        memset(t, 0, sizeof(t));
        memset(g, 0, sizeof(g));
        tot = m = l = 0;
        while (!ve.empty()) ve.pop_back();
        for (int i = 0; i < 205; ++i)
            while (!v[i].empty())
                v[i].pop_back();

        scanf("%d", &n);
        int ans = 0;
        for (int i = 1; i < n; ++i)
        {
            int fr, to;
            scanf("%d%d", &fr, &to);
            v[fr].push_back(to);
            v[to].push_back(fr);
        }
        if (n <= 2)
        {
            printf("Case %d: %d\n", ++te, 1);
            continue;
        }
        int mi = 0x7fffffff;
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 0; j < v[i].size(); ++j)
                mx[i] = max(mx[i], dfs(v[i][j], i));
            mi = min(mi, mx[i]);
        }

        int root = -1;
        mx[n + 1] = -1;
        bool br = false;
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 0; j < v[i].size(); ++j)
                if (mx[i] == mi && mx[v[i][j]] == mi)
                    makeline(i, n + 1),
                    makeline(n + 1, i),
                    root = n + 1,
                    br = true;
                else makeline(i, v[i][j]);
            if (root == -1 || mx[root] > mx[i]) root = i;
        }
        if (br) ++n, ans = -1;
        dp(root, 0);
        for (int i = be[root]; i; i = li[i].next)
            ve.push_back(li[i].to);
        sort(ve.begin(), ve.end(), cmp);
        m = ve.size();
        int sum = 0;
        for (int i = 0; i <= 200; ++i)
            g[0][i][0] = g[0][i][1] = 1;
        for (int i = 1; i <= m; ++i)
        {
            int now = ve[i - 1];
            for (int j = 1; j <= mx[now]; ++j)
            {
                int p = i == 1 ? j : min(j, mx[ve[i - 2]]);
                for (int k = 0; k <= j; ++k)
                    for (int l = 0; l <= sum; ++l)
                        g[i][j][k + l] = (g[i][j][k + l] + f[now][k] * g[i - 1][p][l]) % inf;
            }
            sum += mx[now];
        }
        ++ans;
        int mxx = mx[ve[m - 1]];
        for (int i = 1; i <= mxx; ++i)
            for (int j = i * 2; j <= sum; ++j)
                ans = (ans + g[m][i][j] - g[m][i - 1][j]) % inf;
        printf("Case %d: %d\n", ++te, (ans % inf + inf) % inf);
    }
    fclose(stdin);fclose(stdout);
}

=第三题=
根据点到直线距离公式 可以知道
ans=min(Σ(kxi-yi+b)^2 / (k^2 + 1))
这个可以三分套三分算出最优解(我怎么知道为什么QvQ
算这个式子这个略慢=-=
展开可以发现只要预处理出Σxi、Σxi、Σyi、Σxi^2、Σyi^2、Σxiyi
就可以O(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
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
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <string>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <vector>
#include <functional>
#include <ctime>
#include <cstdlib>
#include <sstream>
#include <set>
#include <deque>
using namespace std;
typedef long long ll;
typedef long double ld;

const int maxn = 1000005;

struct point
{
    int x, y;
}p[maxn];

int n, x, y, a, b, c, sx, sy, sxx, syy, sxy;

ld sqr(ld a)
{
    return a * a;
}

ld calc2(ld k, ld b)
{/*
    ld t = 1 / (k * k + 1);
    ld ans = t * k * k * sxx + t * syy + t * b * b - 2 * k * sxy - 2 * sy * b + 2 * b * k * sx;
    if (ans < 10)
        cout << "Sdf";*/

    return (k * k * sxx + syy + n * b * b - 2 * k * sxy - 2 * sy * b + 2 * b * k * sx) / (k * k + 1);
    /*ld ans = 0;
    for (int i = 0; i < n; ++i)
        ans += sqr(k * p[i].x - p[i].y + b) / (k * k + 1);
    return ans;*/

}

ld calc(ld k)
{
    ld l = -1e9, r = 1e9;
    while (l + 1e-6 < r)
    {
        ld lmid = l + (r - l) / 3,
                     rmid = l + (r - l) / 3 * 2;
        ld v1 = calc2(k, lmid),
                     v2 = calc2(k, rmid);
        if (v1 < v2) r = rmid;
        else l = lmid;
    }
    return calc2(k, l);
}

int main()
{
    freopen("input.in", "r", stdin);
    freopen("output.out", "w", stdout);
    int test;
    scanf("%d", &test);
    for (int te = 1; te <= test; ++te)
    {
        scanf("%d%d%d%d%d%d", &n, &x, &y, &a, &b, &c);
        p[0].x = x, p[0].y = y;
        for (int i = 1; i < n; ++i)
            p[i].x = (a * p[i - 1].x * p[i - 1].x + b * p[i - 1].x + c) % 107,
            p[i].y = (a * p[i - 1].y * p[i - 1].y + b * p[i - 1].y + c) % 107;
        sx = sy = sxx = syy = sxy = 0;
        for (int i = 0; i < n; ++i)
            sx += p[i].x,
            sy += p[i].y,
            sxx += sqr(p[i].x),
            syy += sqr(p[i].y),
            sxy += p[i].x * p[i].y;
        ld l = -1e9, r = 1e9;
        while (l + 1e-6 < r)
        {
            ld lmid = l + (r - l) / 3,
                         rmid = l + (r - l) / 3 * 2;
            ld v1 = calc(lmid),
                         v2 = calc(rmid);
            if (v1 < v2) r = rmid;
            else l = lmid;
        }
        printf("Case %d: %.5f\n", te, (double)calc(l) * acos(-1) / n);
    }
    fclose(stdin);fclose(stdout);
}

下一场考完还不能当队长我也不过如此了啊233

 

 

【福利】各种算法/数据结构的封装模板

一共25个模板 变量名和代码长度什么的就不要在意了。。(变量名下时候养成的[良好]习惯 至于代码长度 我自带常数大出* 不能多说=-=

给的包里有个文档.cpp(乱码的话 用notepad++看就可以了。。)里面有每个类成员的用法

总体就是实例化完了直接调函数即可。。
下面例程里的include和typedef最好全部写上 在模板中使用到这些不会说明

例程:(刚写的acm-icpc world finals 2006B 中间模板的部分被我切掉了 这样看起来比较厉害=v=)

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
#include
#include
#include
#include
#include
#include
#include
#include
#include

<map> #include
#include
#include
#include
#include
#include
#include
using namespace std;
typedef long long ll;
typedef long double ld;
//===========================other=====================
//===========================other=====================
//===========================NetworkCostFlowSpfa=======
//===========================NetworkCostFlowSpfa=======
Network_Cost_Flow_Spfa nf1, nf2;
int n, m;
int main()
{
scanf("%d%d", &amp;n, &amp;m);
int s = n + m + 10, t = n + m + 11;
for (int i = 0; i &lt; n; ++i)
{
int temp;
scanf("%d", &amp;temp);
nf1.makeline(s, i, temp, 0);
nf2.makeline(s, i, temp, 0);
}
for (int i = 0; i &lt; m; ++i)
{
int temp;
scanf("%d", &amp;temp);
nf1.makeline(i + n, t, temp, 0);
nf2.makeline(i + n, t, temp, 0);
}
for (int i = 0; i &lt; n; ++i)
for (int j = 0; j &lt; m; ++j)
{
int fr = i, to = j + n;
double temp;
scanf("%lf", &amp;temp);
if (temp &lt; -0.5) continue;
nf1.makeline(fr, to, 100000, temp);
nf2.makeline(fr, to, 100000, -temp);
}
printf("%.2f to %.2f", nf1.query(s, t).b + 1e-8, -1 * nf2.query(s, t).b + 1e-8);
}

有错误找我QQ:498731903…

下面是算法的列表0 0

1. Suffix_Array
2. Link_Table
3. Link_Table_V
4. Suffix_Auto_Maton
5. KMP
6. AC_Auto_Maton
7. Splay
8. Link_Cut_Tree
9. Segment_Tree
10. Tree_Chain_Division
11. KD_Tree
12. Network_Flow
13. Network_Cost_Flow_Spfa
14. Network_Cost_Flow_Zkw
15. Network_Flow_Up_Down
16. Network_Cost_Flow_Up_Down
17. Mergeable_Tree
18. Hash_Map
19. Geometry_Base
20. Geometry_Polygon
21. Geometry_Round
22. Shortest_Path
23. High_Num
24. Discretization
25. Tarjan

下载:TEMPLATES

acm-icpc world finals 题解格式和说明

格式:

标题:
【World Finals】

内容:
【试题编号】

【名称】

【题目大意】

【算法讨论】

【时空复杂度】
O()
O()
【code】

/*
集训队作业。。
上面格式大概就是找作业要提交的表格的格式
因为每题都要写表格 于是就会每题都写题解了。。。
我觉得没看的价值的题解会加【X】
*/

NOI2013 游记

【day 0】
嘛- –
坐飞机什么的
又晚点了= =
在飞机上写了个弹(dan)飞绵羊
编译过了
样例还没来得及测
后来又忘了。。
于是现在还不知道是对的错的
到了报道的地方后
报道了数小时
回宾馆(为闭幕式被dzd吐槽埋下了伏笔
全场无亮点
这几天安排如下
上午 下午
day1 开幕式 试机
day2 机试① 复测 讲题
day3 玩 玩
day4 机试② 复测 讲题 高校宣讲 签约
day5 团抗 闭幕式
day6 88~

【day1】
开幕式上
各种奇怪的人的奇怪的讲话
怎么感觉去年没那么多人blabla的样子- –
表演什么的还不错
不过有个摄像师全程台上卡位
无力吐槽,,
中午去了他们的食堂
除了没荤菜和全面贯彻落实了每道菜都是辣的的传统
其他还是不错的<其实不是很辣 下午试机 2:30~3:00是笔试 完了试机 笔试AK了! 令人欣慰 其实本来我选终止没有响应进程 我是用killall的 后来试了试 好像只能kill。。于是就换了。。 试机题嘛。。 第一题前队长讲过的后缀数组 我居然忘了QAQ 但是据说论文还有线性的做法orz 另外说下 我们宾馆的空调实在**** 于是今晚就到主任那房间睡 他出去玩了~ 【day2】 机试。。 早上6:40被闹钟叫醒 各种blabla 7:30左右出门了 到体育馆门口呆了会刚好进场 到考试开始整个过程 除了在电脑前等开始的时候有点困 其他来说心态还是比较良好的 8:00 翻开试卷 屹然看到提交答案4字 就有感觉这次考试有点hh了 第一题 60分完后 80分想了会没想出来 就去看第二题 我的解题策略习惯是这样的(这不一定是一个好的策略): 有提交答案 我一般会把它放在11点开始 做两个小时 在现在的情况 第一题的分性价比不是那么大 60分又实在好打 于是我决定接下来可以用大把的时间想第二题 想啊想啊想(具体怎么想的略过。。 到10点才想出一个n^2还会被卡精度的算法 快没什么时间了 果断拍 调 然后第一题 拍 不调 写随机 调 这样blabla完已经11:30 跟我预期有点差距。。 于是我开始拍第三题的前两个暴力点 这个暴力蛋疼 有因为略紧张了 调到考试前5min才调出来 赶快把暴力改了改 改成全1的 吧剩下点都跑了一遍 交卷。 在床上滚了一中午无视 下午看成绩 真心看成绩这心情才是压抑,,走路都腿软。。 第一题70 差不多 第三题29 也还好 虽然比预期低10分 后来发现是搜索尼玛写错了。。 第二题零 尼玛?。。。开始我以为是我的结论,b了 后来看了下输出 保留③位小数******* 论考试结束前看看题目输出格式的重要性。。。。。 其实这题是因为【Pa】 sdfasafgabklvjhasf【考挂自己弱!】 后来听讲题 第一题正解居然是随机性算法- - 第二题我那个结论是对的 只是还有个东西没推出来(+0.5)于是hh 这题我没hh的话+45分。。 第三题有人AK! 各种背包。。。 搜索没错应该可以40分 就是被-11 考挂自己弱不多说 后来好像也没什么亮点 就是知道金线差不多130的时候 “区区30分!二试再来大战30000000000回合!!!!!” 【day3】 玩什么的略显无聊= = 不说 晚上的时候 老师来我们房间发密码条 然后跟我说 第二题spj重写了 然后全场重测 我+45分! 全场重测!!业界良心 不能爽更多 【day4】 第一题 嗯 这不是矩阵嘛 嗯10^10^3啊 尼玛你确定这不是FJOI?! ↓ 第二题 "NOI" 你在逗我- - 果断不做= = ↓ 第三题 想啊想啊想 哦 原来是这样这样这样 有理有据 逆袭有望! ↓ 第一题 我记得有个mod phi定理?= = 就是你了 不管那么多了- - ↓ pa第一题正解 嗯 过样例了 不错不错 ↓ pa第一题暴力 嗯 也过样例了 不错不错 ↓ pa第一题对拍 嗯 correct for n次 不错不错 ↓ 怎么感觉有点有节奏感? 不科学。。 ↓ 原来没srand- -。。 ↓ 还是correct for n次 不错不错 ↓ pa第三题暴力 过样例了 很好! ↓ pa第三题正解 过样例了 很好! ↓ pa第三题对拍 ↓ 检查srand 好像是写了 ↓ correct for n次 very nice ↓ 各种检查输出格式n次 ↓ 考试结束= = 刚出考场就听clq说首长说第一题不能mod phi 而且就算mod phi 也要mod phi + phi QAQ 瞬间有种hh的赶脚 算了 不管那么多了 - - 【下午 又是一个更加坎坷的心情看成绩 先看到缩略图 第一题的result不是都一样的。。。 尼玛! 点开 一大片奇怪的因为 不是correct! 认真一看 Right Output Wahhhhhhhhhhh 第一题90分 然后迅速把它滚到下一页 又是一对一样的。。 直接拉到最后成绩了。。 90+0+100=190!!! 金牌无误了! 瞬间心情愉悦啊haaaaaaaaa 后面一大段全部略过~ 【get THU保送生协议 一份】 【day5】 团抗啊团抗 orz首长和ldf贡献的神代码 我就只是给神代码提提建议的蒟蒻T_T 穿橘黄色衣服特权:前排围观 开始被分到一个奇怪的组 轻松刷进甲组 然后第二次循环赛的时候 被赶到乙组了QAQ 虽然后面又上来了=v= 然后就一直在甲组 各种没出去 然后是分组赛 分到了甲2组 3个喜闻乐见的对手 直接进入第一组! 然后第一次从1~n的刷赛没出去! 这样就一定有前4了啊~ 求前3 求二等~ 【略过一大段 这里都在祈祷河北人民早日被刷掉。。可怕。。 决赛! 开始占据非常好的地形优势 四周无人 他们还都挤在一起 瞬间围出一个巨大的地 锁定胜局!! 后期各种压制+小范围圈地 RANK ONE GET!!!! 真心喜闻乐见 iPad抱回家 下午玩了一下午三国杀 5点开始颁奖(什么心态- - 福建这次是团体总分第二!! 太爽了hahaha 传说总分前三有福利?= = 【day6】 除了例行的晚点 其他也就没什么好说的了 一届又这么刷过了。。

checker in linux

只是放个模板= =

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
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <vector>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <stack>
#include <iostream>
#include <algorithm>
#include <string>
#include <functional>
#include <sstream>
using namespace std;
typedef long long ll;
typedef long double ld;

int main()
{
    for (int i = 1; ; ++i)
    {
        system("./2431_data");
        system("./2431");
        system("./2431_force");
        if (system("diff output.out output2.out"))
        {
            cerr << "ERROR!--" << i << endl;
            break;
        }
        cerr << "PASSED!--" << i << endl;
        system("sleep 1");
    }
}

【minecraft】自动挖矿机器人

对于使用的介绍 请看AB站视频~
传送门:
A站:http://www.acfun.tv/v/ac664839
B站:http://www.bilibili.tv/video/av570910/
游戏存档:http://pan.baidu.com/share/link?shareid=491979&uk=3524964609

这里是对代码的介绍、解释
先贴出全部代码:

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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
n = 50
l = 2
r = 8
delta = 5
function dig(k)
  if k == 1 then
    turtle.dig()
  end
  if k == 2 then
    turtle.digUp()
  end
  if k == 3 then
    turtle.digDown()
  end
end

function go(k)
  if k == 1 then
    if (turtle.forward() == false) then
      if (turtle.getFuelLevel() == 0) then
        turtle.refuel(1)    
      else
        turtle.dig(k)
      end
      go(k)
    end
  end
  if k == 2 then
    if (turtle.up() == false) then
      if (turtle.getFuelLevel() == 0) then
        turtle.refuel(1)
      else
        turtle.digUp()
      end
      go(k)
    end
  end
  if k == 3 then
    if (turtle.down() == false) then
      if (turtle.getFuelLevel() == 0) then
        turtle.refuel(1)        
      else
        turtle.digDown()
      end
      go(k)
    end
  end
  if k == 4 then
    if (turtle.back() == false) then
      if (turtle.getFuelLevel() == 0) then
        turtle.refuel(1)
      else
        turtle.turnLeft()
        turtle.turnLeft()
        turtle.dig()
        turtle.turnLeft()
        turtle.turnLeft()
      end
      go(k)
    end
  end
end

function check(k)
  if k == 1 then
    for i = l, r do
      turtle.select(i)
      if turtle.compare() then
        turtle.select(1)
        return true
      end
    end
  end
  if k == 2 then
    for i = l, r do
      turtle.select(i)
      if turtle.compareUp() then
        turtle.select(1)
        return true
      end
    end
  end
  if k == 3 then
    for i = l, r do
      turtle.select(i)
      if turtle.compareDown() then
        turtle.select(1)
        return true
      end
    end
  end
  turtle.select(1)
  return false
end

function dfs(b)
  if b == 1 then
    for i = 1, 3 do
      if check(i) then
        dig(i)
        go(i)
        dfs(1)
        go(5 - i)
      end
    end  
    turtle.turnLeft()
    if check(1) then
      dig(1)
      go(1)
      dfs(1)
      go(4)
    end
 
    turtle.turnLeft()
    turtle.turnLeft()
    if check(1) then
      dig(1)
      go(1)
      dfs(1)
      go(4)
    end
    turtle.turnLeft()
  else
    if check(1) then
      dig(1)
      go(1)
      dfs(1)
      go(4)
    end
  end
end
local f = io.open("disk/data", "r")
be = tonumber(f:read())
f:close()
print("len:")
len = tonumber(io.read())
for k = be + 1, be + len do
  tot = k * delta
  for i = 1, tot do
    go(1)
    turtle.digUp()
  end
  turtle.turnRight()
  b = false
  for i = 1, n do
    if check(2) then
      b = true
    end
    turtle.digUp()
    if b == true then
      turtle.turnLeft()
      dfs(0)
      go(2)
      dfs(0)
      turtle.turnRight()
      turtle.turnRight()
      if check(2) then
        dig(2)
        go(2)
        dfs(1)
        go(3)
      end
      dfs(0)
      go(3)
      dfs(0)
      turtle.turnLeft()
    end
    if check(3) then
      dig(3)
      go(3)
      dfs(1)
      go(2)
    end
    b = false
    if check(1) then
      b = true
    end
    turtle.dig()
    go(1)
  end
  print("success")
  print(k)
  for i = 1, n do
    go(4)
  end
  turtle.turnLeft()
  for i = 1, tot do
     go(4)
  end
  for i = l, r do
    turtle.select(i)
    turtle.dropDown(turtle.getItemCount(i) - 1)
  end
  for i = r + 1, 16 do
    turtle.select(i)
    turtle.dropDown(64)
  end
  turtle.select(1)
  local f = io.open("disk/data", "w")
  f:write(k)
  f:close()
end

首先 对于一只机器人 挖出的都是形如未命名
的平面矿道 len为输入的 其余为程序内部全局变量
l、r是要匹配的矿物对应于机器人内部的l~r格

dig函数:
机器人的挖掘函数 只是为了好写。。
参数为方向1为前 2为上 3为下 4为后 下同
(dig函数没有后这个方向)
go函数:
机器人的行走函数 主要为了防止行走失败即无燃料时的自动补充
参数为方向
check函数:
检查某个方向是否有匹配矿物
参数为方向
dfs函数:
检查到某个方向有矿物后开始进行深搜 参数用于剪枝 减少不必要检查

然后数主程序部分
首先从数据库中读取上次挖到第几个矿道(len) 这个数据
输入len 为要挖几个矿道
然后就是各种模拟
最后返回后把矿物回收
除了匹配矿物留一个 燃料全部留下 其余都回收
输出”success i”i为挖到第几个矿道
写入data
继续执行下一个矿道的挖矿

这里的实现还是有几个不好的地方:
1.没要燃料的话会死在外面
2.走出更新区域会死在外面
3.如果go时遇到生物 虽然如果生物走开后可以正常运行 但是这可能浪费时间

对于1、2问题 是比较好解决的 只要记录机器人坐标 判断要死的时候往回走就行了
但是要记录这个坐标最好写turn函数 不过我没写。。 所以就没有去实现

对于3问题 其实可以弄一个中控服务器 负责管理机器人 包括战斗机器人 这样就可以适时的派出杀掉那些生物~

然后就会呈现出世界和谐繁荣共同发展的景象~\(≧▽≦)/~

如果如果引入中控电脑 就可以动态管理机器人 多点挖矿 也可以转移矿区 等等

不过很不好的是 机器人不能给机器人写程序 虽然cc引入了合成台后功能是有所增强
如果机器人能给机器人写程序 并且能支持实时保存运行情况 那就非常完美了~
可以做各种blabla的事=v= youknow.

apio2013游记【= =】

day0
  下午1点的飞机 导致在起飞前被各种问房号= =
  飞机还晚点了T_T 
  最后好像4点多了才到吧。。
  到了燕山大酒店 众犇已经准备去玩了 我们把行李扔在宾馆大堂就走了= =
  另外 今年的apio真是奇葩 非常奇葩。。。
  总共只有3天 第一天和第三天上课 第二天考试
  上课是从10点 上到12点  <什么心态= =
  然后12:30才能吃饭 早去就会被赶出来=。=
  下午从1:30就开始上课 上到快6:00。。
  考试那天 从8:00先试一个小时的机 然后直接开始考- – 考到2:00….
  即9:00~14:00= =
day1
  上午钱桥讲提交答案题 教我们如何写comparer
  顺便讲了一些随机化算法(盾神说的可以解决 非多项式题目的算法 用在提交答案题貌似极其合适。。)
  下午先是ural试题选讲
  “这题一定没人听懂 我们来分析下为什么没听懂“——冯齐纬
  然后李超的ural冠军赛题目讲解
day2
  被乱虐的时候终于到了0v0
  第一题是一堆机器人跑啊跑 一开始什么都没看出来 去看第二题
  乍看之下 不是动态树就是神结论 (orz hhs神犇
  想了半天没想出有什么神结论。。 动态树在提交答案题的威压下好像不是很可写。。
  于是决定写k=2的暴力
  第三题叫我们cha人 cha人啊。。 我这种好孩纸从来不cha人的啊 如何cha。。。
  看完题就直接123的写 第一题papapa暴力写完交国际 incorrect 
  想了想 可能国际是像oj一起算的。。 于是交国内 过了3个点
  不信服 加了一个-1 多过了一个点。。。 于是就心满意足的去写第二题。。
   写这个暴力我写了200行我会乱说? 交国际 OK 交国内 过了4个点 喜闻乐见 去玩第三题了。。
  还是有几个水的点的 但是那个chaDJ的真心不会 又看了下后面的那个神秘题目的第二个点有25分 一定不可做!(hehe
  神秘题我连程序都没看 第一个点我直接随机数据直接过了。。 第二个点 也没太多时间了 就无视之= =,  (我是傻b= =
  于是hehe的apio考试就这么过去了= =
  下午看成绩 112分 虽然是有gold 但是感觉好弱= = 第一题dp都木有想出来。。 还有第三题的最后一个点 如果略看下程序应该是可以构造出来的。。
  就这样吧=、=
day3
  木有听课去考acm了 被各种乱虐 我们队做出了5题 很悲剧的C没有做出来 然后就没有然后了。。
  晚上听说集训队名额缩减为50人 但是可能不算去年进过队的
  thu夏令营政策出来 最多加100分
day4
  BACK

  

字符画

今天在到处乱逛的时候发现了这个
好像很好玩~
于是就果断写了一个来玩~ 如图

psb (41)
思路很显然 对于某一块图 用一个亮度差不多的字符代替之
查了三个东西
1:灰度=R*0.299+G*0.587+B*0.114
2:灰度字符表{‘M’, ‘N’, ‘H’, ‘Q’, ‘$’, ‘O’, ‘C’, ‘?’, ‘7’, ‘>’, ‘!’, ‘:’, ‘-‘, ‘;’, ‘.’, ‘ ‘}
3:其实我不懂怎么读bmp= = 于是查了一个读bmp的模板改了一下写成生成这个的~

——————–code———————

#include<math.h>
#include <iomanip.h>
#include <stdlib.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <fstream.h>
const char ch[16] = {‘M’, ‘N’, ‘H’, ‘Q’, ‘$’, ‘O’, ‘C’, ‘?’, ‘7’, ‘>’, ‘!’, ‘:’, ‘-‘, ‘;’, ‘.’, ‘ ‘};
int a[1000][1000];
//—————————————————————————————
//以下该模块是完成BMP图像(彩色图像是24bit RGB各8bit)的像素获取,并存在文件名为xiang_su_zhi.txt中
unsigned char *pBmpBuf;//读入图像数据的指针
int bmpWidth;//图像的宽
int bmpHeight;//图像的高
RGBQUAD *pColorTable;//颜色表指针
int biBitCount;//图像类型,每像素位数
//——————————————————————————————-
//读图像的位图数据、宽、高、颜色表及每像素位数等数据进内存,存放在相应的全局变量中
bool readBmp(char *bmpName)
{
    FILE *fp=fopen(bmpName,”rb”);//二进制读方式打开指定的图像文件
    if(fp==0)
return 0;
    //跳过位图文件头结构BITMAPFILEHEADER
    fseek(fp, sizeof(BITMAPFILEHEADER),0);
    //定义位图信息头结构变量,读取位图信息头进内存,存放在变量head中
    BITMAPINFOHEADER head;
    fread(&head, sizeof(BITMAPINFOHEADER), 1,fp); //获取图像宽、高、每像素所占位数等信息
    bmpWidth = head.biWidth;
    bmpHeight = head.biHeight;
    biBitCount = head.biBitCount;//定义变量,计算图像每行像素所占的字节数(必须是4的倍数)
    int lineByte=(bmpWidth * biBitCount/8+3)/4*4;//灰度图像有颜色表,且颜色表表项为256
    if(biBitCount==8)
{
        //申请颜色表所需要的空间,读颜色表进内存
        pColorTable=new RGBQUAD[256];
        fread(pColorTable,sizeof(RGBQUAD),256,fp);
}
    //申请位图数据所需要的空间,读位图数据进内存
    pBmpBuf=new unsigned char[lineByte * bmpHeight];
    fread(pBmpBuf,1,lineByte * bmpHeight,fp);
    fclose(fp);//关闭文件
    return 1;//读取文件成功
}
//—————————————————————————————–
//给定一个图像位图数据、宽、高、颜色表指针及每像素所占的位数等信息,将其写到指定文件中
bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height, int biBitCount, RGBQUAD *pColorTable)
{
    //如果位图数据指针为0,则没有数据传入,函数返回
    if(!imgBuf)
        return 0;
    //颜色表大小,以字节为单位,灰度图像颜色表为1024字节,彩色图像颜色表大小为0
    int colorTablesize=0;
    if(biBitCount==8)
        colorTablesize=1024;
    //待存储图像数据每行字节数为4的倍数
    int lineByte=(width * biBitCount/8+3)/4*4;
    //以二进制写的方式打开文件
    FILE *fp=fopen(bmpName,”wb”);
    if(fp==0)
return 0;
    //申请位图文件头结构变量,填写文件头信息
    BITMAPFILEHEADER fileHead;
    fileHead.bfType = 0x4D42;//bmp类型
    //bfSize是图像文件4个组成部分之和
    fileHead.bfSize= sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + colorTablesize + lineByte*height;
    fileHead.bfReserved1 = 0;
    fileHead.bfReserved2 = 0;
    //bfOffBits是图像文件前3个部分所需空间之和
    fileHead.bfOffBits=54+colorTablesize;
    //写文件头进文件
    fwrite(&fileHead, sizeof(BITMAPFILEHEADER),1, fp);
    //申请位图信息头结构变量,填写信息头信息
    BITMAPINFOHEADER head;
    head.biBitCount=biBitCount;
    head.biClrImportant=0;
    head.biClrUsed=0;
    head.biCompression=0;
    head.biHeight=height;
    head.biPlanes=1;
    head.biSize=40;
    head.biSizeImage=lineByte*height;
    head.biWidth=width;
    head.biXPelsPerMeter=0;
    head.biYPelsPerMeter=0;
    //写位图信息头进内存
    fwrite(&head, sizeof(BITMAPINFOHEADER),1, fp);
    //如果灰度图像,有颜色表,写入文件
    if(biBitCount==8)
        fwrite(pColorTable, sizeof(RGBQUAD),256, fp);
    //写位图数据进文件
    fwrite(imgBuf, height*lineByte, 1, fp);
    //关闭文件
    fclose(fp);
    return 1;
}
//—————————————————————————————-
//以下为像素的读取函数
void doIt()
{
    //读入指定BMP文件进内存
    freopen(“output.out”, “w”, stdout);
    char readPath[]=”t.bmp”;
    readBmp(readPath);
    //输出图像的信息
    cout<<“width=”<<bmpWidth<<” height=”<<bmpHeight<<” biBitCount=”<<biBitCount<<endl;
    //循环变量,图像的坐标
    //每行字节数
    int lineByte=(bmpWidth*biBitCount/8+3)/4*4;
    //循环变量,针对彩色图像,遍历每像素的三个分量
    int m=0;
if(biBitCount==24)
{//彩色图像
for(int i=0;i<bmpHeight;i++)
{
for(int j=0;j<bmpWidth;j++)
{
                long double t = *(pBmpBuf+i*lineByte+j*3+0) * 0.299 + *(pBmpBuf+i*lineByte+j*3+1) * 0.587 + *(pBmpBuf+i*lineByte+j*3+2) * 0.114;
                a[i][j] = (int)t;
            }
        }
        int bgx = 2;
        int bgy = 1;
        for (int i = bmpHeight / bgx; i >= 0; i–)
        {
          for (int j = 0; j < bmpWidth / bgy + 1; j++)
          {
            int sum = 0;
            for (int x = i * bgx; x < (i + 1) * bgx; x++)
              for (int y = j * bgy; y < (j + 1) * bgy; y++) sum += (x >= bmpHeight || y >= bmpWidth) ? 256 : a[x][y];
            cout << ch[(int)(((double)sum) / (bgx * bgy) / 16)];
          }
          cout << endl;
        }
//cout<<“总的像素个素为:”<<n<<endl;
cout<<“—————————————————-“<<endl;
}
    fclose(stdout);
}
int main()
{
    doIt();
}

 

【题解?】 三维迷宫【coding in minecraft】

从前。。有个逆天的游戏叫minecraft
这个游戏有多逆天。。你懂得- –
尤其是有各种奇葩的mod 各种逆天啊。。。。。
我就在想有没有可以给机器人写程序让他帮你做事的mod。。
结果。。居然还真有!!
这个mod 叫computercraft 有一个叫做turtle的东西
就是机器人 可以执行  行走  判断方块 破坏方块  收集物品 放置物品 控制周围的红石信号 的操作
用的是一个叫lua的脚本语言 果断去玩了一下~~
写了一个程序 用来走三维迷宫的..
效果:

psb (36)

运行3d.lua
psb (37)

路途中..

psb (40)

找到终点后 挖掉钻石块

psb (38)

之后返航~~~

psb (39)

【code】

x = 0
y = 0
z = 0
b = {}
for i = -20, 20 do
  b[i] = {}
  for j = -20, 20 do
    b[i][j] = {};
for k = -20, 20 do
 b[i][j][k] = 0;
end
  end
end
t = {}
  t[0] = {}
  t[0][0] = 0
  t[0][1] = 1
  t[1] = {}
  t[1][0] = 1
  t[1][1] = 0
  t[2] = {}
  t[2][0] = 0
  t[2][1] = -1
  t[3] = {}
  t[3][0] = -1
  t[3][1] = 0
function get()
  print(“Get!”)
end
function abs(a)
  if (a < 0) then return -a
  else return a end
end
function check()
  if (abs(x) > 20 or abs(y)  > 20 or abs(z) > 20 or b[x][y][z] == 1) then return false
  else return true end
end
function dfs(d)
  b[x][y][z] = 1
  if (turtle.detectUp() == false) then
    z = z + 1
if (check() == true) then
 turtle.up(1)
 dfs(d)
 turtle.down(1)
end
z = z – 1
  else
    if (turtle.compareUp() == true) then
 turtle.digUp()
 get()
end
  end
  if (turtle.detectDown() == false) then
    z = z – 1
if (check() == true) then
 turtle.down(1)
 dfs(d)
 turtle.up(1)
end
z = z + 1
  else
    if (turtle.compareDown() == true) then
 turtle.digDown()
 get()
end
  end
  td = d
  local i = 0
  for i = 0, 3 do
    if (turtle.detect() == false) then
 x = x + t[td][0]
 y = y + t[td][1]
 if (check() == true) then
   turtle.forward()
dfs(td)
   turtle.back()
 end
 x = x – t[td][0]
 y = y – t[td][1]
    else
      if (turtle.compare() == true) then
   turtle.dig()
   get()
 end
    end
td = (td + 1) % 4
turtle.turnRight()
  end
end
dfs(0)

============================================================
写得略渣。。就是一个纯搜索

玩过mc应该就能想象这个mod的强大
这个还支持无线控制 可以做各种东西
比如轰炸机什么的= =
挖矿就扔一堆这个机器人去挖就行了
自动种东西 自动收割不再是梦想!!
而且这只是挖矿的 还有旁边带剑的
弄一堆出来组一个杀手团什么的 ~~
基本就没什么不能自动了

还有 它作为可以运行的程序 可以同时访问外面的系统和mc里的世界
是一个极强的通道
可以按照游戏里的各种摆放对你的电脑进行一些改变
比如可以建一颗文件夹树来表示mc里的一个矿洞什么的
【虽然可能有环= =】
或者在你挂mc做别的事的时候弹出一个窗口
距离你500m出现一只野生古力帕
什么的

就感觉这个mod让mc的拓展性极大地增加啊 碉堡了~~~~~