電脳言語のオルダーソンループ / ネット・ガーディアンの奮闘

前几天惊闻上次那个《工程师死绝的世界》的社这回居然联动石头门出了个写代码游戏，我当即兴冲冲地跑去了。

去了之后先是注册账号，要 素 过 多。然后开始打，剧情看了几眼就没兴趣了，看知乎上说是什么你教labmem们写代码的。

前几题就纯普及组，可能唯一的障碍是读题。最后一题是个找环的，反正noip第一题难度，但是我WA了好几发，因为没特判自环其实不算一个环。

然后收集下面的乌帕，除了第二个之外都蛮简单，第二个巨NM阴间，题意是给你个30×30的矩阵，让你求一个权值和尽可能大的连通块。一下子把我们队三个都问住了，我问了学弟们，也不是很会的样子。然后我突然发现这几把题居然就是让你写非完美算法，草。这不得赶紧退火安排上。

还是有点不好退的。我一开始是初始每个位置1/2的概率选，然后调整。统计答案就是DFS一遍求最大的连通块，交上去41k，榜上最后一名是50k，我就想办法优化。后来想到初状态可以设置成所有为正的选，为负的不选。后来又想到可以设置成负的有1/2的几率选，这时已经优化到46k了。但是还是有问题，咋整，疯狂调参呗，但是还是调不上去。

这时我突然发现时限不是1s，然后我加大力度，把退火的温度变化量调小，马上就49k了，胜利近在眼前。之后也没想到啥靠谱的优化，就调随机种子，结果他给了我好运。他的生日是最好用的随机种子，直接51k上榜。我想着不如多随机几次，但是每次都没他高，我还发现我迟迟没上榜，仔细一看，这个榜居然不是取最高分数，而是取最新提交分数，大草。幸好我还记得那次的随机种子，重回51k了，截止目前是rank14。

/**
 *  There is no end though there is a start in space. ---Infinity.
 *  It has own power, it ruins, and it goes though there is a start also in the star. ---Finite.
 *  Only the person who was wisdom can read the most foolish one from the history.
 *  The fish that lives in the sea doesn't know the world in the land.
 *  It also ruins and goes if they have wisdom.
 *  It is funnier that man exceeds the speed of light than fish start living in the land.
 *  It can be said that this is an final ultimatum from the god to the people who can fight.
 *
 *  Steins;Gate
**/

#include <bits/stdc++.h>
typedef long long LL;
inline char gc() {
    //return getchar();
    static char buf[100000], *p1 = buf, *p2 = buf;
    if(p1 == p2) {
        p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
    }
    return (p1 == p2) ? EOF : *p1++;
}

template <typename T>
inline void read(T& x) {
    x = 0;
    char c(gc());
    int f(1);
    while(c < '0' || c > '9') {
        if(c == '-') {
            f = -1;
        }
        c = gc();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = gc();
    }
    x *= f;
}

inline LL read() {
    LL x;
    read(x);
    return x;
}

const int N = 32, INF = 0x3f3f3f3f;

const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};

int a[N][N], n, m, vis[N][N], fin, ans, tempans;
int Ans[N][N], dfn[N][N], tot, Ans2[N][N], top, X[900 * 1000 + 10], Y[900 * 1000 + 10], tpp;

const double oldT = 1000;
const double eps = 1e-4;
const double dT = 0.99995;
const int Time = 1;

inline int rd(int l, int r) {
    return ((((LL)rand()) << 32) + rand()) % (r - l + 1) + l;
}

inline double Rand() {
    return 1.0 * rand() / RAND_MAX;
}

inline bool valid(int x, int y) {
    if(x < 1 || y < 1 || x > n || y > m || !vis[x][y] || dfn[x][y]) {
        return false;
    }
    return true;
}

void DFS(int x, int y) {
    dfn[x][y] = ++tot;
    tempans += a[x][y];
    for(int i = 0; i < 4; i++) {
        if(valid(x + dx[i], y + dy[i])) {
            DFS(x + dx[i], y + dy[i]);
        }
    }
    return;
}

void DFS2(int x, int y) {
    dfn[x][y] = ++tot;
    Ans2[x][y] = 1;
    for(int i = 0; i < 4; i++) {
        if(valid(x + dx[i], y + dy[i])) {
            DFS2(x + dx[i], y + dy[i]);
        }
    }
    return;
}

inline int cal() {
    int ans = -INF;
    tot = 0;
    memset(dfn, 0, sizeof(dfn));
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(!dfn[i][j] && vis[i][j]) {
                tempans = 0;
                DFS(i, j);
                ans = std::max(ans, tempans);
            }
        }
    }
    return ans;
}

inline void init() {
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(a[i][j] > 0) {
                vis[i][j] = 1;
            }
            else {
                vis[i][j] = rd(-1000, -1) <= a[i][j];
            }
        }
    }
    ans = cal();
    // printf("ans = %d 
", ans);
    if(ans > fin) {
        fin = ans;
        memcpy(Ans, vis, sizeof(Ans));
    }
    return;
}

int main() {

    srand(19260817);
    read(n);
    read(m);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            read(a[i][j]);
            if(a[i][j] < 0) {
                ++top;
                for(int k = 1000; k >= -a[i][j]; k--) {
                    X[++tpp] = i;
                    Y[tpp] = j;
                }
            }
        }
    }

    if(top == 0) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                printf("1");
            }
            puts("");
        }
        return 0;
    }

    if(top == n * m) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                printf("0");
            }
            puts("");
        }
        return 0;
    }

    for(int A = 1; A <= Time; A++) {
        double T = oldT;
        init();
        while(T > eps) {
            int id = rd(1, tpp);
            int x = X[id], y = Y[id];
            vis[x][y] ^= 1;
            int New = cal();
            if(New > fin) {
                fin = New;
                memcpy(Ans, vis, sizeof(vis));
            }
            if(New > ans || Rand() < exp((New - ans) / T)) {
                ans = New;
            }
            else {
                vis[x][y] ^= 1;
            }
            T *= dT;
        }
    }
    tot = 0;
    memset(dfn, 0, sizeof(dfn));
    memcpy(vis, Ans, sizeof(Ans));
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(!dfn[i][j] && vis[i][j]) {
                tempans = 0;
                DFS(i, j);
                if(tempans == fin) {
                    // find
                    memset(dfn, 0, sizeof(dfn));

                    tot = 0;
                    DFS2(i, j);
                    // out
                    for(int I = 1; I <= n; I++) {
                        for(int J = 1; J <= m; J++) {
                            printf("%d", Ans2[I][J]);
                        }
                        puts("");
                    }
                    exit(0);
                }
            }
        }
    }

    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            printf("0");
        }
        puts("");
    }
    //printf("%d
", fin);
    puts("FUCK!!!");
    return 0;
}