2022 RoboCom 世界机器人开发者大赛-本科组（省赛）RC-u4 攻略分队 (已完结)

其它题目

题目

RC-u4 攻略分队

副本是游戏里的一个特色玩法，主要为玩家带来装备、道具、游戏资源的产出，满足玩家的游戏进程。

在 MMORPG《最终幻想14》里，有一个攻略人数最大达到 56 人的副本“巴尔德西昂兵武塔”，因为有在副本里死亡不能复活、机制比较整蛊等特点，一度被玩家视作洪水猛兽。

在副本的开始，我们会遇到第一个难关：攻略的玩家要分为两组，同时讨伐副本 BOSS “欧文”和“亚特”。

已知以下信息：

1. 玩家会组成 6 支队伍进入副本，其中第 i 队有 Vi位玩家（i=1,⋯,6）。
2. 每支队伍可能会有一些特殊角色：MT（主坦克）、工兵（负责探测陷阱）和指挥（负责指挥玩家）。

我们的任务是合理安排玩家的分组，以最大程度增加副本通过概率。分组的原则如下：

1. 要将所有队伍分成 2 组，每支队伍必须且仅属于其中一组；
2. 每组必须有至少一个 MT（主坦克）。

如果满足上述原则的分组方案不唯一，则按照下列规则确定唯一解：

1. 优先选择每组有至少一个指挥和至少一个工兵的方案；
2. 如果规则 1 无法满足，则优先选择每组至少有一个指挥的方案；
3. 如果所有方案都不满足规则 2，或经过前 2 个规则筛选后，分组方案仍不唯一，则选择两边人数尽可能接近（即两边人数差尽可能小）的方案；
4. 如果满足规则 3 的方案还不唯一，选择讨伐“欧文”的人数比讨伐“亚特”的人数更多的方案；
5. 如果满足规则 4 的方案还不唯一，选择讨伐“欧文”的队伍编号方案中最小的一个。

注: 一个队伍编号方案A = {a1 < ··· < am} 比B = {b1 < ··· bn}小， 当且仅当存在1 <= k <= min(m, n)使得ai = bi， 对所有0 < i < k成立， 且ak < bk.
本题就请你给出满足所有分组原则的分配方案。

输入格式:
输入第一行给出 6 支队伍的玩家数量，即 6 个非负整数 V i(0≤Vi≤8,1≤i≤6)。队伍人数为 0 时表示队伍不存在。

随后 6 行，按队伍编号顺序，每行给出一支队伍的特殊角色，格式为 ABC，其中 A 对应 MT，B 对应工兵，C 对应指挥。三种角色对应取值 0 或 1，0 表示没有该角色，1 表示有。

注：由于可能存在一人兼任多个特殊角色的情况，所以一支队伍中的特殊角色数量有可能大于该队伍的玩家数量。

输出格式:
输出分两行，第一行输出讨伐“欧文”的队伍编号，第二行输出讨伐“亚特”的队伍编号。同一行中的编号按升序输出，以 1 个空格分隔，行首尾不得有多余空格。

如果不存在合法的方案，输出GG。

输入样例1:

6 8 7 5 3 0
010
101
110
001
111
000

输出样例1:

2 3
1 4 5

输入样例2:

6 8 7 5 3 0
010
101
010
001
011
000

输出样例2:

GG

题解

概述
这道题思路很简单， 但逻辑处理非常的复杂。
基本思想是暴力搜索， 我们枚举每一种方案， 将方案与目前最优的方案进行比较， 将最优方案更新为两者中最优的方案

枚举
将一组序列（1~6）分为两部分， 我们可以采用dfs+回溯来实现
假设要分为的两组为t1, t2
对于序列中每个数字, 都有两种选择:进入t1或进入t2. 所以我们分别让当前数字进入t1和t2, 然后继续枚举下一个数字, 当六个数字都枚举完成后我们就得到了一种组合, 此时我们再将当前组合与最优组合进行判断

vector<int> tmp1, tmp2;//存放两个组各自的成员

void dfs(int i)//i为队伍编号
{
    if(i > 6)//枚举完成, 进行判断
    {
        judge();
        return;
    }
    if(num[i] == 0)//当前队伍为空, 直接跳过
    {
        dfs(i+1);
        return;
    }
    
    //当i加入t1
    tmp1.push_back(i);
    dfs(i+1);
    tmp1.pop_back();

    //当i加入t2
    tmp2.push_back(i);
    dfs(i+1);
    tmp2.pop_back();
}

判断
太长太复杂, 请跳转到程序注释
为了避免多重嵌套循环, 在程序中大量的使用了return, 每次return都代表着当前判断结束

AC代码(含注释)

虽然很长但都很好懂

#include <bits/stdc++.h>

using namespace std;
const int N = 7;
int num[N];//各队伍的人数
bool A[N], B[N], C[N];//各队伍是否有坦克、工兵、指挥
int totalA;//坦克的总数

//目前的最优方案， 1、2 对应 欧文、亚特
vector<int> ans1, ans2;
/* RO, R1, R2对应前三个规则所要求的性质
 * R0: 是否满足 每组必须有至少一个 MT（主坦克）。
 * R1: 是否满足 每组有至少一个指挥和至少一个工兵
 * R2: 是否满足 每组至少有一个指挥
 */
bool R0, R1, R2;


vector<int> tmp1, tmp2;//当前要判断的方案

void judge()
{
    //所有人都在一组， 不符合分组要求， 直接退出
    if(tmp1.empty() || tmp2.empty()) return;

    //当前方案的r0, r1, r2性质， 以及临时变量t1, t2
    bool r0, r1, r2, t1, t2;

    //判断方案的r0性质
    t1 = t2 = false;
    for(int i : tmp1)
        if( A[i] ) {
            t1 = true;
            break;
        }
    for(int i : tmp2)
        if( A[i] ) {
            t2 = true;
            break;
        }
    r0 = t1 && t2;
    if(!r0) return;//r0是硬性要求， 不满足直接不考虑

    //判断方案的r2性质, 先判断r2是因为r2是r1的组成部分
    t1 = t2 = false;
    for(int i : tmp1)
        if( C[i] ) {
            t1 = true;
            break;
        }
    for(int i : tmp2)
        if( C[i] ) {
            t2 = true;
            break;
        }
    r2 = t1 && t2;

    //判断方案的r1性质
    t1 = t2 = false;
    for(int i : tmp1)
        if( B[i] ) {
            t1 = true;
            break;
        }
    for(int i : tmp2)
        if( B[i] ) {
            t2 = true;
            break;
        }
    r1 = r2 && t1 && t2;

    //规则0, R0为false说明最优方案为空
    if( !R0 )
    {
        ans1 = tmp1, ans2 = tmp2;
        R0 = r0, R1 = r1, R2 = r2;
        return;
    }

    //规则1
    if(R1 && !r1) return;
    if(r1 && !R1)
    {
        ans1 = tmp1, ans2 = tmp2;
        R0 = r0, R1 = r1, R2 = r2;
        return;
    }

    //都不满足规则1时执行规则2
    if(!R1 && !r1)
    {
        if(R2 && !r2) return;
        if(r2 && !R2)
        {
            ans1 = tmp1, ans2 = tmp2;
            R0 = r0, R1 = r1, R2 = r2;
            return;
        }
    }

    //规则3
    int an1 = 0, an2 = 0, tn1 = 0, tn2 = 0;//各组人数
    for(int i : ans1) an1 += num[i];
    for(int i : ans2) an2 += num[i];
    for(int i : tmp1) tn1 += num[i];
    for(int i : tmp2) tn2 += num[i];
    
    int d1 = abs(an1 - an2), d2 = abs(tn1 - tn2);//人数差
    if(d1 < d2) return;
    if(d1 > d2)
    {
        ans1 = tmp1, ans2 = tmp2;
        R0 = r0, R1 = r1, R2 = r2;
        return;
    }

    //规则四
    t1 = (an1 > an2), t2 = (tn1 > tn2);
    if(t1 && !t2) return;
    if(t2 && !t1)
    {
        ans1 = tmp1, ans2 = tmp2;
        R0 = r0, R1 = r1, R2 = r2;
        return;
    }
    
    //规则5
    for(int k=0; k<ans1.size() && k < tmp1.size(); k++)
    {
        if(ans1[k] < tmp1[k]) return;
        else if(ans1[k] > tmp1[k])
        {
            ans1 = tmp1, ans2 = tmp2;
            R0 = r0, R1 = r1, R2 = r2;
            return;
        }
    }
    /*
     可以发现虽然代码长, 但其实都差不多
     基本就是:
        如果最优方案满足某个规则而当前方案不满足, 判断结束
        如果最优方案不满足某个规则而当前方案满足, 则当前方案替换最优方案, 判断结束
        如果都满足, 执行下一个规则
     */
}

void dfs(int i)
{
    if(i > 6)
    {
        judge();
        return;
    }
    if(num[i] == 0)
    {
        dfs(i+1);
        return;
    }
    tmp1.push_back(i);
    dfs(i+1);
    tmp1.pop_back();

    tmp2.push_back(i);
    dfs(i+1);
    tmp2.pop_back();
}

int main()
{
    for(int i=1; i<=6; i++)
        cin >> num[i];
    string ABC;
    for(int i=1; i<=6; i++)
    {
        cin >> ABC;
        if(ABC[0] == '1') A[i] = true, totalA++;
        if(ABC[1] == '1') B[i] = true;
        if(ABC[2] == '1') C[i] = true;
    }
    if(totalA < 2)//出现GG的情况有且仅有少于两个队伍有坦克
    {
        cout << "GG";
        return 0;
    }
    else
    {
        dfs(1);
        for(int i=0; i<ans1.size(); i++)
        {
            if(i != 0) cout << " ";
            cout << ans1[i];
        }
        cout << endl;
        for(int i=0; i<ans2.size(); i++)
        {
            if(i != 0) cout << " ";
            cout << ans2[i];
        }
    }
    return 0;
}

如上代码可AC, 有问题欢迎讨论交流