2020编码大赛（6）决赛

2020编码大赛题目  2020编码大赛（1）题目_编码赛题-CSDN博客

决赛，是8个队伍选出4个队伍并选出冠军亚军季军。

一，需求变更
1，在基地对自身装载能力升级：资源机器人默认装载能力为1024KB，通过装载能力升级，扩容自身最大负载，每扩容1024KB花费 30 金币，购买数量不限。
2，能量掠夺者，由资源机器人从己方基地购买，购买金额 30 金币。
3，系统默认金币数0。
4，回合调度顺序
（1）回合开始
（2）第一队的资源机器人或能量掠夺者开始调度
（3） 第一队还未调度的机器人开始调度
（4）第二队的资源机器人或能量掠夺者开始调度
（5）第二队还未调度的机器人开始调度
（6） 回合结束
5，兑换规则：
红色资源：每收集1单位 ，得分+1
绿色资源：每收集1单位 ，得分+2
蓝色资源：每收集1单位 ，得分+4

二，初步分析

1，不会有人主动创造异常
2，掠夺者的作用小于负载升级
3，如果买了掠夺者，那就先掠夺者，再机器人
4，先挖红矿得金币，扩负载，再挖蓝矿得分，绿矿是最差的

三，核心策略

核心策略有2个：

（1）购买策略，买负载升级、买掠夺者、买能量的平衡

（2）挖矿策略，挖红矿优先、挖蓝矿优先的平衡

然后我展开了一系列的建模计算：

然而最后也没能得到比较好的模型，就写了个垃圾代码。

挖矿策略：

static int targetCol()
{
    if (g_myTeam.worker.maxLoad / 1024 < 5 || g_myTeam.worker.power < 30) {
        return g_targetCol = maxColor();
    }
    return g_targetCol = minColor();
}

购买策略：

static int leftRounds()
{
    return allRemainResource() / ((g_enemyTeam.worker.maxLoad + g_myTeam.worker.maxLoad) / 1024);
}

// 购买掠夺者
static void purchaseLooter()
{
    int num = max(30 - g_myTeam.worker.power, 0);
    if (g_myTeam.golds >= num + 30 && !hasLooter() && g_myTeam.worker.maxLoad / 1024 >= 3 &&
        neighborNum(g_enemyTeam.campPos) < 4) {
        setPurchaseCommand("BUY_LOOTER");
        g_myTeam.golds -= 30;
    }
}

static int maxmaxload()
{
    return (g_enemyTeam.worker.maxLoad / 1024 * 3 + 1) * 1024;
}

// 购买负载升级
static void purchaseLoad()
{
    if (leftRounds() < 3) {
        return;
    }
    int num = max(60 - g_myTeam.worker.power, 0);
    while (g_myTeam.golds >= num + 30 && g_myTeam.worker.maxLoad < maxmaxload()) {
        g_myTeam.golds -= 30;
        setPurchaseCommand("UPGRADE_LOAD");
        g_myTeam.worker.maxLoad += 1024;
    }
}
// 购买能量
static void purchasePower()
{
    for (int i = 0; i < 60 - g_myTeam.worker.power; i++) {
        setPurchaseCommand("BUY_POWER");
    }
}

矿的优先级：

static void play(Pos start, Pos end, vector<Pos> &path)
{
    vector<Pos> tar(2);
    tar[0] = start;
    tar[1] = end;
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            g_mapEntities2[i][j] = g_mapEntities[i][j];
        }
    }
    g_power2 = g_myTeam.worker.power;
    int colist[3];
    if (targetCol() == maxColor()) {
        if (RED == maxColor()) {
            colist[0] = RED, colist[1] = BLUE, colist[2] = GREEN;
        } else {
            colist[0] = GREEN, colist[1] = BLUE, colist[2] = RED;
        }
    } else {
        if (BLUE == minColor()) {
            colist[0] = BLUE, colist[1] = RED, colist[2] = GREEN;
        } else {
            colist[0] = GREEN, colist[1] = RED, colist[2] = BLUE;
        }
    }
    while (getPathSize(tar) < remainSize() && g_myTeam.worker.power > 0) {
        if (!getTarget(tar, colist[0])) {
            break;
        }
        if (samePos(g_posFlag, end)) {
            goto point;
        }
    }
    while (getPathSize(tar) < remainSize() && g_myTeam.worker.power > 0) {
        if (!getTarget(tar, colist[1])) {
            break;
        }
        if (samePos(g_posFlag, end)) {
            goto point;
        }
    }
    while (getPathSize(tar) < remainSize() && g_myTeam.worker.power > 0) {
        if (!getTarget(tar, colist[2])) {
            break;
        }
        if (samePos(g_posFlag, end)) {
            goto point;
        }
    }
point:
    g_myTeam.worker.power = g_power2;
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            g_mapEntities[i][j] = g_mapEntities2[i][j];
        }
    }
    if (samePos(*(tar.end() - 1), g_posFlag)) {
        tar.erase(tar.end() - 1);
    }
    int ret = getPath(tar, path);
    if (ret == -1) {
        cout << endl << "play1()    ret = -1" << endl;
        return;
    }
}

static bool cmp(ResourceUnit a, ResourceUnit b)
{
    if (a.gemType != b.gemType) {
        if (g_targetCol == maxColor()) {
            return a.gemType > b.gemType;
        }
        return a.gemType < b.gemType;
    }
    return a.sizeOfUnit > b.sizeOfUnit;
}

掠夺者优先：

static void looterFirst()
{
    if (g_turn2 == g_myTeam.looter.playerName && g_turn2 != "") {
        g_turn = g_turn2;
    }
}

四，修复遗留bug

1，半决赛定时机制

// 估算压缩一份资源的大小
int getOneSize()
{
    if (g_onesize) {
        return g_onesize;
    }
    g_onesize = COMSIZE;
    if (g_collectHistory.size()) {
        int sizesum = 0, numsum = 0;
        for (unsigned int i = 0; i < g_collectHistory.size(); i++) {
            sizesum += g_collectHistory[i].sizeOfCompressionUnit;
            numsum += g_collectHistory[i].sizeOfUnit / 1024;
        }
        g_onesize = sizesum / numsum + 1;
    }
    return g_onesize;
}

int compress(string s)
{
    freopen(s.c_str(), "r", stdin);
    g_com = 0, g_flag = true;
    if (clock() - g_start > 8 * CLOCKS_PER_SEC) { // 这个分支应该走不到
        return getOneSize();
    }
    compress();
    return g_com / 1024 + 1;
}