2021 RoboCom 世界机器人开发者大赛-本科组（初赛）题解

最新推荐文章于 2024-07-29 21:31:45 发布

CarryNotKarry

最新推荐文章于 2024-07-29 21:31:45 发布

阅读量6k

点赞数 9

分类专栏：比赛总结文章标签：算法

本文链接：https://blog.csdn.net/Carry_hkr/article/details/120750379

版权

比赛总结专栏收录该内容

7 篇文章 0 订阅

订阅专栏

写在前面

这是一个新的比赛，上周六考了4个题，虽然晋级了后面的比赛，但是情况很不理想，我觉得进入最后的决赛有点危险了，补一下这四个题，我觉得挺好的，正好反思反思自己。

虽然说这是天梯赛L2的难度，但是我当时考试的时候感觉并不好，只A了第一个题，觉得应该是L3的难度，但是自己后面补题发现没有到L3难度，大概在L2-L3之间。总的来看，第一题A了，第二题17分，不知道哪里写错了，后面补题也wa了一个点（好多人都是没有A），第三题是图论，我当时看错题了，只有16分，跑dij也不至于16分，第四题当时暴力dfs只有1分，很离谱，有的点竟然是wa...后面大佬们教了教正解如何去写。

7-1 懂得都懂

题目

众所周知，在互联网上有很多话是不好直接说出来的，不过一些模糊的图片仍然能让网友看懂你在说什么。然而对这种言论依然一定要出重拳，所以请你实现一个简单的匹配算法。

现在我们采集了原图的一些特征数据，由 N 个小于 255 的非负整数组成，假设对于给定的若干张由 Mi 个同样小于 255 的非负整数组成的新图的特征数据，每个数据都可以由原图中任意四个不同数据的平均值计算而来，则称新图为原图的相似图片。对于给出的数据，请你判断是不是相似图片。

注意，不同数据指的并非是数据的值不同，而是不能取同一个数据多次。对于两个相同值的数据，如果给出两次，则可以取两次。

输入格式:

输入第一行是两个整数 N,K (1 ≤ N ≤ 50, 1 ≤ K ≤ 200)，表示采集的原图的特征数据个数和新图的张数。

接下来一行为 N 个小于 255 的非负整数，表示原图的特征数据。

最后的 K 行，每行第一个数是 Mi (1 ≤ Mi ≤ 200)，表示新图的特征数据个数。然后是 Mi 个小于 255 的非负整数，表示新图的特征数据。

输出格式:

对于每一张新图，如果为相似图片，则在一行中输出 Yes，否则输出 No。

输入样例:

5 3
4 8 12 20 40
3 11 16 19
3 12 16 19
10 11 11 11 11 11 11 11 11 11 11

输出样例:

Yes
No
Yes

题意

给出n个数，n小于等于50，有k个询问，每个询问里有若干个数字x，问是否能用一开始n个数中不同下标的4个数字来表示4*x

思路

考试的时候，一个简单题目被写成这个样子，真的很让人炸心态（吐槽一下）

因为n不大，我们可以用dfs模拟所有情况出来，大致就是50个里面选4个嘛，C(50,4)，时间复杂度不大，然后存下来表示可以组成这个数字，最后在询问的时候判断是否可以即可

代码

const int N = 51;
int n,m,a[N],k,x;
unordered_map<int,int> mp;
inline void dfs(int x,int num,int sum)
{
    if (num==4) 
    {
        mp[sum]=1;
        return;
    }
    for (int i=x+1;i<=n+num-3;i++)
        dfs(i,num+1,sum+a[i]);
}
inline void Case_Test()
{
    cin>>n>>m;
    for (int i=1;i<=n;i++)
        cin>>a[i];
    dfs(0,0,0);
    while (m--)
    {
        cin>>k;
        bool boo=true;
        for (int i=1;i<=k;i++)
        {
            cin>>x;
            if (mp[x*4]) continue;
            boo=false;
        }
        if (boo) cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
}

7-2 芬兰木棋

题目

芬兰木棋（Mölkky，又称芬兰木柱）是源自芬兰的一项运动。哲哲将这个运动改造成了赛博朋克单人版，现在场上一开始有 N 根立起的小木棋（上面分别标有一个非负整数），哲哲投掷一根大木棋去击倒这些小木棋以获得分数。分数规则如下：

如果仅击倒 1 根木棋，则得木棋上的分数。
如果击倒 2 根或以上的木棋，则只得击倒根数的分数。（例如击倒 5 根，则得 5 分。）

哲哲固定站在 (0,0) 点上，四周放着若干个小木棋 (Xi,Yi)，坐标均为整数。每次哲哲可以朝一个方向扔出大木棋，大木棋会打倒这个方向上离哲哲最近的 k 个小木棋。哲哲游戏水平很高超，所以这个 k 可以自由控制。

请问哲哲最多能拿多少分，在获得最多分数的情况下最少需要扔出多少次大木棋？

规则与真实规则有较大出入，真实游玩时请以国际莫尔基组织的规则为准

输入格式:

输入第一行是一个正整数 N (1 ≤ N ≤ $10^5$ )，表示场上一开始有 N 个木棋。

接下来 N 行，每行 3 个整数 Xi,Yi,Pi，分别表示木棋放置在 (Xi,Yi)，木棋上的分数是 Pi。坐标在 32 位整数范围内，分数为小于等于 1000 的正整数。

保证 (0,0) 点没有木棋，也没有木棋重叠放置。

输出格式:

输出一行两个数，表示最多分数以及获得最多分数最少需要投掷大木棋多少次。

输入样例:

输出样例:

1022 9

题意

给出n个数，每个数在(Xi,Yi)的位置，有着Pi的得分，我们每次站在原点(0,0)往一个方向扔一个大木棋，可以让它在任何一个地方停，问得分最大是多少，然后问最少需要投多少次。

得分规则有两种：

如果仅击倒 1 根木棋，则得木棋上的分数。
如果击倒 2 根或以上的木棋，则只得击倒根数的分数。（例如击倒 5 根，则得 5 分。）

思路

题目一开始写的是非负整数，我把0也考虑进去了，比如一个方向只有0，那么就不需要扔，然后如果有{1,0,0,0,1}情况等等...但是按道理来讲没有什么影响，应该还能多几分的。

这个题很显然需要把它划分成很多部分，按照斜率来，每一个斜率有一个vector容器来存位置和Pi得分值，但是这是无序的，所以我们需要对每个vector容器sort一遍。然后开始扫，如果碰到连续的1的话，就不需要多扔一次，按照这个思路可以简化成如下的：

很明显，ans1就是Pi的和，因为题目要求是最大的，那么ans2首先就是n（n个物体扔n次），如果对于扫的时候有连续的1，那么就ans2--，因为可以少一次。

对于每一个斜率k，我是用map来存它是第几条，实际上可以用pair来存分子和分母，因为可能有精度问题（但是这个题应该没有问题，有人这么写还是wa掉一个点）。

注意的是同一个斜率不是有两个方向嘛，但是一个从0,1,2,...,+oo，一个从0,-1,-2,...,-oo，排序的方式不一样，我是用两个vector来区分。

代码

const int N = 1e6+7;
vector<pair<ll,ll> > v3,v4;
vector<pair<ll,ll> > v1[N],v2[N];
unordered_map<double,int> mp1,mp2;
int cnt1,cnt2,n,w;
double k,x,y;
ll ans1,ans2;
inline void Case_Test()
{
    cin>>n;
    ans2=n;
    for (int i=1;i<=n;i++)
    {
        cin>>x>>y>>w;
        ans1+=w;
        if (x==0)
        {
             if (y>0) v3.push_back({y,w});
             else v4.push_back({-y,w});
             continue;
        }
        k=y*300/x;
        if (y>0)
        {
            if (!mp1[k]) mp1[k]=++cnt1;
            v1[mp1[k]].push_back({y,w});
        }
        else
        {
            if (!mp2[k]) mp2[k]=++cnt2;
            v2[mp2[k]].push_back({-y,w});
        }
    }
    for (int i=1;i<=cnt1;i++)
    {
        sort(v1[i].begin(),v1[i].end());
        for (int j=1;j<v1[i].size();j++)
            if (v1[i][j].second==1&&v1[i][j-1].second==1) ans2--;
    }
    for (int i=1;i<=cnt2;i++)
    {
        sort(v2[i].begin(),v2[i].end());
        for (int j=1;j<v2[i].size();j++)
            if (v2[i][j].second==1&&v2[i][j-1].second==1) ans2--;
    }
    for (int i=1;i<v3.size();i++) 
        if (v3[i].second==1&&v3[i-1].second==1) ans2--;
    for (int i=1;i<v4.size();i++)
        if (v4[i].second==1&&v4[i-1].second==1) ans2--;
    cout<<ans1<<" "<<ans2;
}

7-3 打怪升级

题目

很多游戏都有打怪升级的环节，玩家需要打败一系列怪兽去赢取成就和徽章。这里我们考虑一种简单的打怪升级游戏，游戏规则是，给定有 N 个堡垒的地图，堡垒之间有道路相连，每条道路上有一只怪兽把守。怪兽本身有能量，手里的武器有价值。打败怪兽需要的能量等于怪兽本身的能量，而怪兽一旦被打败，武器就归玩家所有 —— 当然缴获的武器价值越高，玩家就越开心。

你的任务有两件：

帮助玩家确定一个最合算的空降位置，即空降到地图中的某个堡垒，使得玩家从这个空降点出发，到攻下最难攻克（即耗费能量最多）的那个堡垒所需要的能量最小；
从这个空降点出发，帮助玩家找到攻克任意一个其想要攻克的堡垒的最省能量的路径。如果这种路径不唯一，则选择沿途缴获武器总价值最高的解，题目保证这种解是唯一的。

输入格式:

输入第一行给出两个正整数 N (≤1000) 和 M，其中 N 是堡垒总数，M 是怪兽总数。为简单起见，我们将堡垒从 1 到 N 编号。随后 M 行，第 i 行给出了第 i 只怪兽的信息，格式如下：

B1 B2 怪兽能量 武器价值

其中 B1 和 B2 是怪兽把守的道路两端的堡垒编号。题目保证每对堡垒之间只有一只怪兽把守，并且 怪兽能量 和 武器价值 都是不超过 100 的正整数。

再后面是一个正整数 K（≤N）和玩家想要攻克的 K 个目标堡垒的编号。

输出格式:

首先在一行中输出玩家空降的堡垒编号 B0。如果有多种可能，则输出编号最小的那个。

随后依次为玩家想要攻克的每个堡垒 B 推荐最省能量的攻克路径，并列出需要耗费的能量值和沿途缴获武器的总价值。注意如果最省力的路径不唯一，则选择沿途缴获武器总价值最高的解。格式为：

B0->途经堡垒1->...->B
总耗费能量 武器总价值

输入样例:

输出样例:

5
5->2
2 1
5->1->3
12 7
5->4->6
10 7
5
0 0

题意

看题吧...图论题

思路

跑一遍Floyd可以得出我们选择的那个点s，然后再跑一遍得到到询问的路径最小的，然后武器最大的，注意Floyd是如何存路径的

代码

const int N = 1007;
int u,v,n,m,g[N][N],w[N][N],temp,s,x;
int path[N][N],dist[N][N];
inline void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                if (dist[i][k]+dist[k][j]<dist[i][j])
                    dist[i][j]=dist[i][k]+dist[k][j],path[i][j]=k,g[i][j]=g[i][k]+g[k][j];
                if (dist[i][k]+dist[k][j]==dist[i][j]&&g[i][k]+g[k][j]>g[i][j])
                    path[i][j]=k,g[i][j]=g[i][k]+g[k][j];
            }
}
inline void output(int i,int j)
{
    if(i==j) return;
    if(path[i][j]==0) cout<<"->"<<j;
    else
    {
        output(i,path[i][j]);
        output(path[i][j],j);
    }
}

inline void Case_Test()
{
    cin>>n>>m;
    memset(w,0x7f/3,sizeof(w));
    memset(g,0,sizeof(g));
    memset(dist,0x7f/3,sizeof(dist));
    for (int i=1;i<=n;i++) w[i][i]=g[i][i]=0;
    for (int i=1;i<=m;i++)
    {
        int x,y;
        cin>>u>>v>>x>>y;
        dist[u][v]=dist[v][u]=x;
        w[v][u]=w[u][v]=x;
        g[v][u]=g[u][v]=y;
    }
    for (int k=1;k<=n;k++)
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++)
                if (w[i][j]>w[i][k]+w[k][j])
                    w[i][j]=w[i][k]+w[k][j];
    /*for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=n;j++)
            cout<<w[i][j]<<" ";
        cout<<endl;
    }*/
    temp=inf;
    for (int i=1;i<=n;i++)
    {
        int tmp=-1;
        for (int j=1;j<=n;j++)
        {
            if (i==j) continue;
            if (w[i][j]>tmp) tmp=w[i][j];
        }
        if (tmp<temp) temp=tmp,s=i;
    }
    cout<<s<<endl;
    floyd();
    cin>>m;
    while (m--)
    {
        cin>>x;
        cout<<s;
        output(s,x);
        if (s==x) cout<<"\n0 0\n";
        else
        cout<<endl<<dist[s][x]<<" "<<g[s][x]<<endl;
    }
}

ps：我不知道为什么s==x的时候会出错...不是0，0

7-4 疫情防控

题目

疫情尚未结束，严防疫情反复。为了做好疫情防控工作，国内设置了地区风险等级，对于中高风险地区的人员采取限制移动、居家隔离等手段。

为了研究疫情防控对于跨地区交通运输的影响，假设现在有 N 个机场，M 条航线，每天都会新增一个防控地区，一个防控地区会导致一个机场无法正常运作，航线也自然无法正常运行，每天会有 Qi 对旅客从 Xi 机场前往 Yi 机场，请计算有多少对旅客会受到影响无法完成行程。

旅客只要能直达或通过若干次中转，且乘坐的所有航线的出发和到达机场都正常运作，即视作可完成行程。

输入格式:

输入第一行是三个整数 N,M,D (1≤N≤5×104, 1≤M≤2×105, 1≤D≤103), 表示机场数、航线数以及新增防控地区的天数。

接下来首先有 M 行，每行给出空格分隔的两个数字 A 和 B，表示编号为 A 和 B 的机场之间有一条航线。航线是双向的，机场编号从 1 到 N。

然后是 D 块输入，每块输入内第一行为空格分隔的两个整数 C 和 Q （1≤Q≤103)，表示新增机场编号为 C 所在的城市为防控地区，今天有 Q 段行程。数据保证新增的城市之前一定不是防控地区。

接下来的 Q 行，每行是空格分隔的两个数字 X 和 Y，表示编号为 X 和 Y 的机场的一段行程。行程有可能包括之前就已经成为防控地区的城市。

输出格式:

对于每天的询问，请在一行中输出在新增了一个防控地区后当天的行程有多少不能成行。

输入样例:

输出样例:

1
2
3

题意

给出一个无向图，有D次，依次关闭当前节点，每次都有若干个询问问你x,y是否还是连接的。

思路

用并查集的思想。

这个题实在是没有想到反向，将输入全部读入存下来，反向开始加入，这样就只需要一遍，处理完当前的就去一次加入看是否能加，然后以此类推。

一开始要注意，把所有无论如何都满足的条件的边加入。

代码

const int N =2e5+7;
int father[N];
inline int find(int x)
{
    return father[x]==x?x:father[x]=find(father[x]);
}
struct node
{
    int to,next,x;
}edge[N<<1];
int head[N],cnt;
vector<int> que,ans;
inline void add(int x,int to)
{
    edge[++cnt].next=head[x];
    edge[cnt].x=x;
    edge[cnt].to=to;
    head[x]=cnt;
}
int n,m,d,x,y,c,q,fx,fy;
vector<pair<int,int> > v[1007];
bool vis[N];
inline void Case_Test()
{
    cin>>n>>m>>d;
    for (int i=1;i<=n;i++) father[i]=i;
    for (int i=1;i<=m;i++)
    {
        cin>>x>>y;
        add(x,y);add(y,x);
    }
    for (int i=1;i<=d;i++)
    {
        cin>>c>>q;
        que.push_back(c);
        vis[c]=1;
        for (int j=1;j<=q;j++)
        {
            cin>>x>>y;
            v[i].push_back({x,y});
        }
    }
    for (int i=1;i<=cnt;i++)
    {
        x=edge[i].x;
        y=edge[i].to;
        //cout<<i<<" "<<x<<" "<<y<<endl;
        if (!vis[x]&&!vis[y])
        {
            fx=find(x);fy=find(y);
            if (fx!=fy) father[fy]=fx;
        }
    }
    for (int i=d;i>=1;i--)
    {
        c=que[i-1];q=v[i].size();
        cnt=0;
        for (auto p:v[i])
        {
            x=p.first;y=p.second;
            fx=find(x);fy=find(y);
            if (fx!=fy) cnt++;
        }
        ans.push_back(cnt);
        x=c;
        for (int j=head[x];j;j=edge[j].next)
        {
            y=edge[j].to;
            if (vis[y]) continue;
            fx=find(x);fy=find(y);
            if (fx!=fy) father[fy]=fx;
        }
        vis[c]=0;
    }
    for (int i=ans.size()-1;i>=0;i--)
        cout<<ans[i]<<endl;
}