AtCoder题解 —— AtCoder Beginner Contest 184 —— E - Third Avenue - BFS

最新推荐文章于 2023-01-17 21:18:47 发布
最新推荐文章于 2023-01-17 21:18:47 发布
阅读量528 收藏
点赞数 1
分类专栏： OJ题解 # AtCoder题解 文章标签： AtCoder题解 ABC184 E题 Third Avenue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justidle/article/details/110477550
版权

题目相关

题目链接

AtCoder Beginner Contest 184 E 题，https://atcoder.jp/contests/abc184/tasks/abc184_e。

Problem Statement

There is a town represented as a two-dimensional grid with H horizontal rows and W vertical columns.
A character ai,j describes the square at the i-th row from the top and j-th column from the left. Here, ai,j is one of the following: S , G , . , # , a, ..., and z.
# represents a square that cannot be entered, and a, ..., z represent squares with teleporters.

Takahashi is initially at the square represented as S. In each second, he will make one of the following moves:

  • Go to a non-# square that is horizontally or vertically adjacent to his current position.
  • Choose a square with the same character as that of his current position, and teleport to that square. He can only use this move when he is at a square represented as a, ..., or z.

Find the shortest time Takahashi needs to reach the square represented as G from the one represented as S.
If the destination is unreachable, report -1 instead.

Input

Input is given from Standard Input in the following format:

H W
a1,1 ... a1,w
.
.
.
ah,1 ... ah,w

Output

Print the shortest time Takahashi needs to reach the square represented as G from the one represented as S.
If the destination is unreachable from the initial position, print -1 instead.

Samples1

Sample Input 1

2 5
S.b.b
a.a.G

Sample Output 1

4

Explaination

Let (i,j) denote the square at the i-th row from the top and j-th column from the left.
Initially, Takahashi is at (1,1). One way to reach (2,5) in four seconds is:

  • go from (1,1) to (2,1);
  • teleport from (2,1) to (2,3), which is also an a square;
  • go from (2,3) to (2,4);
  • go from (2,4) to (2,5).

Samples2

Sample Input 2

11 11
S##...#c...
...#d.#.#..
..........#
.#....#...#
#.....bc...
#.##......#
.......c..#
..#........
a..........
d..#...a...
.#........G

Sample Output 2

14

Samples3

Sample Input 3

11 11
.#.#.e#a...
.b..##..#..
#....#.#..#
.#dd..#..#.
....#...#e.
c#.#a....#.
.....#..#.e
.#....#b.#.
.#...#..#..
......#c#G.
#..S...#...

Sample Output 3

-1

Constraints

  • 1≤H,W≤2000
  • ai,j is S, G, ., #, or a lowercase English letter. There is exactly one square represented as S and one square represented as G.

题解报告

题目翻译

有一个城镇可以用二维网格表示，该城镇水平方向有 H 行，垂直方向有 W 列。字符 a_{i,j} 描述最上边开始的第 i 行最左面开始的第 j 列，它的值是：S，G，.，#，a，...，z 其中一个。# 表示这个点不能进入，小写字母 a ~ z 表示传送点。

高桥开始的的位置为 S，他每次可以按照以下规则移动：

  • 向相邻的位置移动，只要这个位置不是 #。
  • 如果这里是传送点，高桥可以传送到字母相同的传送点。

请找出高桥从 S 到 G 的最短路径，如果不存在，输出 -1。

题目分析

看完题目描述，走迷宫并且是找出最短路线，那么必然使用 BFS。本题和 BFS 模板相比，多了一个传送点，如何解决传送点问题。根据题目意思，我们一共有四种走法，即上、右、下、左。

我的思路是这样的：

1、在某个点判断下一个位置的时候，不考虑下一个点是否是传送点，和原有的 BFS 一样进行移动。

2、所有下一个可能位置计算完成后，判断这个点是否是传送点。如果是传送点，遍历修改传送点的代价 cost。修改结束，清空所有传送点。

下面我们使用样例数据来验证一下思路。

样例数据 1 分析

根据样例数据，起点在 (1,1) 位置。一般算法竞赛都将左上角定义为 1,1。起点的代价 cost 为 0，其余点的 cost 都为 INT_MAX。我们按照上、右、下、左进行遍历。首先将起点 (1,1) 加入到 BFS 的遍历队列中。下面我们开始模拟整个 BFS 遍历过程。

初始状态

cost 数组的值为

 12345
10INT_MAXINT_MAXINT_MAXINT_MAX
2INT_MAXINT_MAXINT_MAXINT_MAXINT_MAX

第一轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (1,1)，并删除该数据，我们从 (1,1) 开始遍历。目前的代价为 0，从这里出发到下一个位置的代价将为 2。

(1,1) 向上

新位置为 (1,0)，走出了迷宫，不是合法位置。忽略。

(1,1) 向右

新位置为 (2,1)，是合法位置，而且不是 #，可以走。当前 cost[2][1]=INT_MAX，更新 cost[2][1]=1，并吧 (2,1) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有一个元素，即 (2,1)。

(1,1) 向下

新位置为 (1,2)，是合法位置，而且不是 #，可以走。当前 cost[1][2]=INT_MAX，更新 cost[1][2]=1，并吧 (1,2) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有两个元素，即 (2,1)、(1,2)。

(1,1) 向左

新位置为 (0,1)，走出了迷宫，不是合法位置。忽略。

判断 (1,1) 是不是传送点

当前位置 (1,1) 不是传送点。

第一轮 BFS 遍历结束

cost 数组的值为

 12345
101INT_MAXINT_MAXINT_MAX
21INT_MAXINT_MAXINT_MAXINT_MAX

第二轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (2,1)，并删除该数据，我们从 (2,1) 开始遍历。目前的代价为 1，从这里出发到下一个位置的代价将为 2。

(2,1) 向上

新位置为 (2,0)，走出了迷宫，不是合法位置。忽略。

(2,1) 向右

新位置为 (3,1)，走出了迷宫，不是合法位置。忽略。

(2,1) 向下

新位置为 (2,2)，是合法位置，而且不是 #，可以走。当前 cost[2][2]=INT_MAX，更新 cost[2][2]=2，并吧 (2,2) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有三个元素，即 (1,2)、(2,2)。

(2,1) 向左

新位置为 (1,1)，是合法位置，而且不是 #，可以走。当前 cost[1][1]=0，而我们移动的代价是 2，所以忽略。

判断 (2,1) 是不是传送点

当前位置 (2,1) 的值为 a，是传送点。遍历迷宫中所有值为 a 的传送点，可以传送的位置有 (2,3)，将这个点的 cost 都改为 2，也就意味着 (1,1)->(3,2) 的代价是 2，同时将着两点加入到 BFS 队列中。此时 BFS 的遍历队列只有四个元素，即 (1,2)、(2,2)、(2,3)。同时我们清空所有 a 的传送点。

第二轮 BFS 遍历结束

cost 数组的值为

 12345
101INT_MAXINT_MAXINT_MAX
2122INT_MAXINT_MAX

第三轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (1,2)，并删除该数据，我们从 (1,2) 开始遍历。目前已经的代价是 1，从这里出发到下一个位置的代价将为 2。

(1,2) 向上

新位置为 (1,1)，是合法位置，而且不是 #，可以走。当前 cost[1][2]=0，而我们移动的代价是 2，就是从 (1,2) 移动到 (1,1) 的代价是 2。所以忽略。

(1,2) 向右

新位置为 (2,2)，是合法位置，而且不是 #，可以走。新的路径代价没有缩小，忽略。说明我们不管是从 (1,1)->(2,1)->(2,2) 或者 (1,1)->(1,2)->(2,2) 的代价都是一样的。

(1,2) 向下

新位置为 (1,3)，是合法位置，而且不是 #，可以走。当前 cost[1][3]=INT_MAX，更新 cost[1][3]=2，并吧 (1,3) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有三个元素，即 (2,2)、(2,3)、(1,3)。

(1,2) 向左

新位置为 (0,2)，走出了迷宫，不是合法位置。忽略。

判断 (1,2) 是不是传送点

当前位置不是传送点。

第三轮 BFS 遍历结束

cost 数组的值为

 12345
1012INT_MAXINT_MAX
2122INT_MAXINT_MAX

第四轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (2,2)，并删除该数据，我们从 (2,2) 开始遍历。目前已经的代价是 2，从这里出发到下一个位置的代价将为 3。

(2,2) 向上

新位置为 (2,1)，是合法位置，而且不是 #，可以走。当前 cost[2][1]=1，而我们移动的代价是 3。所以忽略。

(2,2) 向右

新位置为 (3,2)，走出了迷宫，不是合法位置。忽略。

(2,2) 向下

新位置为 (2,3)，是合法位置，而且不是 #，可以走。当前 cost[2][3]=2，而我们移动的代价是 3。所以忽略。

(2,2) 向左

新位置为 (1,2)，是合法位置，而且不是 #，可以走。当前 cost[1][2]=1，而我们移动的代价是 3。所以忽略。

判断 (2,2) 是不是传送点

当前位置不是传送点。

第四轮 BFS 遍历结束

cost 数组的值为

 12345
1012INT_MAXINT_MAX
2122INT_MAXINT_MAX

第五轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (2,3)，并删除该数据，我们从 (2,3) 开始遍历。目前已经的代价是 2，从这里出发到下一个位置的代价将为 3。

(2,3) 向上

新位置为 (2,2)，是合法位置，而且不是 #，可以走。当前 cost[2][2]=2，而我们移动的代价是 3。所以忽略。

(2,3) 向右

新位置为 (3,3)，走出了迷宫，不是合法位置。忽略。

(2,3) 向下

新位置为 (2,4)，是合法位置，而且不是 #，可以走。当前 cost[2][4]=INT_MAX，更新 cost[2][4]=3，并吧 (2,4) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有三个元素，即 (1,3)、(2,4)。

(2,3) 向左

新位置为 (1,3)，是合法位置，而且不是 #，可以走。当前 cost[1][3]=2，而我们移动的代价是 3。所以忽略。

判断 (2,3) 是不是传送点

当前位置是传送点。但是这个传送点已经处理了，上面我们处理的时候，将这个队列清空。

第五轮 BFS 遍历结束

cost 数组的值为

 12345
1012INT_MAXINT_MAX
21223INT_MAX

第六轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (1,3)，并删除该数据，我们从 (1,3) 开始遍历。目前已经的代价是 2，从这里出发到下一个位置的代价将为 3。

(1,3) 向上

新位置为 (1,2)，是合法位置，而且不是 #，可以走。当前 cost[1][2]=1，而我们移动的代价是 3。所以忽略。

(1,3) 向右

新位置为 (2,3)，是合法位置，而且不是 #，可以走。当前 cost[2][3]=2，而我们移动的代价是 3。所以忽略。

(1,3) 向下

新位置为 (1,4)，是合法位置，而且不是 #，可以走。当前 cost[1][4]=INT_MAX，更新 cost[1][4]=3，并吧 (2,4) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有三个元素，即 (2,4)、(1,4)。

(1,3) 向左

新位置为 (0,3)，走出了迷宫，不是合法位置。忽略。

判断 (1,3) 是不是传送点

当前位置是传送点 b。我们可以从这里传送到 (1,5)。当前 cost[1][5]=INT_MAX，更新 cost[1][5]=3，并吧 (1,5) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有三个元素，即 (2,4)、(1,4)、(1,5)。清空传送点 b。

第六轮 BFS 遍历结束

cost 数组的值为

 12345
101233
21223INT_MAX

第七轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (2,4)，并删除该数据，我们从 (2,4) 开始遍历。目前已经的代价是 3，从这里出发到下一个位置的代价将为 4。

(2,4) 向上

新位置为 (2,3)，是合法位置，而且不是 #，可以走。当前 cost[2][3]=2，而我们移动的代价是 4。所以忽略。

(2,4) 向右

新位置为 (3,4)，走出了迷宫，不是合法位置。忽略。

(2,4) 向下

新位置为 (2,5)，是合法位置，而且不是 #，可以走。当前 cost[2][5]=INT_MAX，更新 cost[2][5]=4，并吧 (2,5) 加入到 BFS 的遍历队列，此时 BFS 的遍历队列只有三个元素，即 (1,4)、(1,5)、(2,5)。

(2,4) 向左

新位置为 (1,4)，是合法位置，而且不是 #，可以走。当前 cost[1][4]=3，而我们移动的代价是 4。所以忽略。

判断 (2,4) 是不是传送点

当前位置不是传送点。

第七轮 BFS 遍历结束

cost 数组的值为

 12345
101233
212234

第八轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (1,4)，并删除该数据，我们从 (1,4) 开始遍历。目前已经的代价是 3，从这里出发到下一个位置的代价将为 4。

(1,4) 向上

新位置为 (1,3)，是合法位置，而且不是 #，可以走。当前 cost[1][3]=2，而我们移动的代价是 4。所以忽略。

(1,4) 向右

新位置为 (2,4)，是合法位置，而且不是 #，可以走。当前 cost[2][4]=3，而我们移动的代价是 4。所以忽略。

(1,4) 向下

新位置为 (1,5)，是合法位置，而且不是 #，可以走。当前 cost[1][5]=4，而我们移动的代价是 4。所以忽略。

(1,4) 向左

新位置为 (0,4)，走出了迷宫，不是合法位置。忽略。

判断 (1,4) 是不是传送点

当前位置不是传送点。

第八轮 BFS 遍历结束

cost 数组的值为

 12345
101233
212234

第九轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (1,5)，并删除该数据，我们从 (1,5) 开始遍历。目前已经的代价是 3，从这里出发到下一个位置的代价将为 4。

(1,5) 向上

新位置为 (1,4)，是合法位置，而且不是 #，可以走。当前 cost[1][4]=3，而我们移动的代价是 4。所以忽略。

(1,5) 向右

新位置为 (2,5)，是合法位置，而且不是 #，可以走。当前 cost[2][5]=4，而我们移动的代价是 4。所以忽略。

(1,5) 向下

新位置为 (1,6)，走出了迷宫，不是合法位置。忽略。

(1,5) 向左

新位置为 (0,5)，走出了迷宫，不是合法位置。忽略。

判断 (1,5) 是不是传送点

当前位置是传送点，但已经处理过。

第九轮 BFS 遍历结束

cost 数组的值为

 12345
101233
212234

第十轮 BFS 遍历队列

BFS 遍历队列不为空，获取队首位置，得到 (2,5)，并删除该数据，我们从 (2,5) 开始遍历。目前已经的代价是 4，从这里出发到下一个位置的代价将为 5。

(2,5) 向上

新位置为 (2,4)，是合法位置，而且不是 #，可以走。当前 cost[2][4]=3，而我们移动的代价是 5。所以忽略。

(2,5) 向右

新位置为 (3,5)，走出了迷宫，不是合法位置。忽略。

(2,5) 向下

新位置为 (2,6)，走出了迷宫，不是合法位置。忽略。

(2,5) 向左

新位置为 (1,5)，是合法位置，而且不是 #，可以走。当前 cost[1][5]=3，而我们移动的代价是 5。所以忽略。

判断 (2,5) 是不是传送点

当前位置是传送点，但已经处理过。

第十轮 BFS 遍历结束

cost 数组的值为

 12345
101233
212234

到这里为止，BFS 队列为空，说明我们遍历了迷宫的所有点。遍历完成。

注意：只要 BFS 第一次走到终点，BFS 就可以停止了，因为 BFS 可以保证第一次就是最短路径。

AC 参考代码

//https://atcoder.jp/contests/abc184/tasks/abc184_e
//E - Third Avenue
#include <bits/stdc++.h>

using namespace std;

//如果提交到OJ，不要定义 __LOCAL
//#define __LOCAL

const int MAXH=2e3+4;
const int MAXW=2e3+4;
char maze[MAXH][MAXW];
int cost[MAXH][MAXW];

int h,w;
pair<int, int> qd;
pair<int, int> zd;
vector<pair<int, int>> tele[26];

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

int bfs() {
    queue<pair<int, int>> q;
    q.push(qd);
    cost[qd.first][qd.second]=0;

    while (true!=q.empty()) {
        pair<int, int> cur = q.front();
        q.pop();

        int nc=cost[cur.first][cur.second]+1;//下一个位置的代价

        //新位置
        for (int i=0; i<4; i++) {
            int nx = cur.first+dx[i];
            int ny = cur.second+dy[i];

            //合法性判断
            if (nx<1||nx>h||ny<1||ny>w||'#'==maze[nx][ny]) {
                continue;
            }
            //路径判断
            if (nc<cost[nx][ny]) {
                cost[nx][ny]=nc;
                q.emplace(nx, ny);
                //判断是不是终点
                if (nx==zd.first && ny==zd.second) {
                    return nc;
                }
            }
        }

        //如果是传送点
        if (maze[cur.first][cur.second]>='a' && maze[cur.first][cur.second]<='z') {
            //将所有的
            vector<pair<int, int>> &t=tele[maze[cur.first][cur.second]-'a'];
            vector<pair<int, int>>::iterator it;
            for (it=t.begin(); it!=t.end(); it++) {
                if (nc<cost[it->first][it->second]) {
                    cost[it->first][it->second]=nc;
                    q.emplace(it->first, it->second);
                }
            }
            t.clear();
        }
    }
    return -1;
}

int main() {
#ifndef __LOCAL
    //这部分代码需要提交到OJ，本地调试不使用
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#endif
    
    cin>>h>>w;
    for (int i=1; i<=h; i++) {
        for (int j=1; j<=w; j++) {
            cost[i][j]=INT_MAX;

            cin>>maze[i][j];
            if ('S'==maze[i][j]) {
                //起点
                qd.first=i;
                qd.second=j;
                cost[i][j]=0;
            } else if ('G'==maze[i][j]) {
                zd.first=i;
                zd.second=j;
            } else if (maze[i][j]>='a' && maze[i][j]<='z') {
                tele[maze[i][j]-'a'].emplace_back(i, j);
            }
        }
    }

    //开始BFS
    cout<<bfs()<<"\n";

#ifdef __LOCAL
    //这部分代码不需要提交到OJ，本地调试使用
    system("pause");
#endif
    return 0;
}

时间复杂度

O(HW)。

空间复杂度

O(HW)。

努力的老周
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
AtCoder Beginner Contest 184 E (bfs)
weixin_43899268的博客
11-23 272
题意： 一个n*m的地图，每个格子的图案为S , G , . ,#,a~z。 从S走到G,每次只能从4个方向走或者相同字母任意传送，求最小步数 题解： 先存下来每个字母的位置。然后bfs时当前字符为a~z时，看是否是第一次走过，如果是的话就对所有为相同字符的字母进行入队，然后标记当前字母已经遍历过，否则直接跳过该操作。其他的操作就和普通的bfs一样，向4个方向遍历，具体操作看代码。 #include<bits/stdc++.h> using namespace std; typedef long
题解：AtCoder Beginner Contest 260 E - At Least One
06-12
代码
Codeforces1344 B. Monopole Magnets（思维/构造）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
08-29 192
题意： 给定一张n*m的矩阵，每个格子要么是黑色，要么是白色。 现在要求你在上面放置若干个南/北磁极，其中每行每列至少要有一个南磁极， 每次可以激活一对在同行或同列的南北磁极，使得北磁极向南磁极移动一格（南磁极不可移动）。 要求在移动过程中，白色格子上不能有北磁极经过，而每个黑色格子在可能的操作下都可能被经过， 问最少需要放置多少个北磁极，才能走遍图中所有黑色格子， 如果无解输出 -1。 数据范围：n,m<=1e3 ...
AtCoder Beginner Contest 184 E - Third Avenue
一个小菜鸡的博客
11-29 226
官方题解 还参考了这位大佬的代码（算是一样了）AtCoder Beginner Contest 184 E Third Avenue | 多传送门搜索_一只酷酷光儿的博客-CSDN博客 传送门搜索把我整蒙了，首先为每一个位置设置一个最小到达时间数组（vis），用bfs不断去更新vis数组，搜索的时候，只要达到一个字母位置，就可以达到所有和它一样字母的位置，最后答案就在相应的位置坐标上。正在上传…重新上传取消正在上传…重新上传取消 // #pragma GCC optimize(2) #inclu
AtCoder Beginner Contest 184
qq_37978559的博客
07-04 147
AtCoder Beginner Contest 184A - DeterminantB - QuizzesC - Super RyumaD - increment of coins 导读： 简单的题目，只说明题意，或者直接说明结论 下面的难题，会做详细的解释和证明 立个flag，在座的大佬们做个见证：一个月刷60场ABC，现在2021/7/4，第十九天，已打卡十六场。 A - Determinant 公式 void work() { int a, b, c, d; cin >> a
题解：AtCoder Beginner Contest 265C - Belt Conveyor (atcoder.jp)
06-18
这篇题解是关于AtCoder Beginner Contest 265C题目——"Belt Conveyor"的解决方案。这是一道入门级别的算法问题，主要考察的是模拟和边界条件处理能力。在这个问题中，你需要模拟一个传送带系统，并根据给定的网格...
题解：AtCoder Beginner Contest 265 E - Warp (atcoder.jp)
最新发布
06-19
代码
题解：AtCoder Beginner Contest 260 D - Draw Your Cards
06-09
代码
题解：AtCoder Beginner Contest 260 D-Changing Jewels
06-06
代码
atcoder11-16日刷题总结
小学生蒟蒻
01-17 670
4.abc270-D 设f_i表示剩下i颗石头时Takahashi可以获得的最大石子数，那么如果我们这次拿走了a_j颗石子，然后对方最多获得f_i-aj颗石子，剩下的i-f_(i-a_j)颗石子就是Takahashi的了。第一次是二分目标点x的位置，对于中点mid，如果矩阵[(1,1),(mid,n)]的棋子数量等于mid，那么就是l移动，否则就是移动r。二分一个x，表示对于每一个篮子i，都拿出min(ai,x)个苹果的情况，显然我们需要的答案时最大的x。注意：存的时候不能把>n的存了，否则会re。
atcoder 190 E - Magical Ornament(BFS+状态压缩)
一个小菜鸡的博客
07-14 186
通过1≤K≤17比较容易看出这道题目需要用状压dp,先处理出c[i]到其他点的最短距离，然后状压更新当前路径的最小答案，最后枚举一下终点得到答案。 // #pragma GCC optimize(2) // #include <random> // #include <windows.h> // #include <ctime> #include <algorithm> #include <iostream> #include <sstr
AtCoder Beginner Contest 246 E - Bishop 2 「01bfs」
Suryxin's blogs
04-04 600
E - Bishop 2 题目描述： 给你一个n * n的矩阵，起点和终点确定，你只能沿对角线走，走的距离可以任意，但是从(x1, y1)走到(x2, y2)的过程中不能存在障碍物，且坐标必须合法，问最下需要几步能到达 思路： 经典bfs，第一反应是暴力bfs，四个方向，每个方向最多走n米… 这个题给了6秒，确实可以卡过去，不过很难卡:( 这个题可以用01bfs来做,每个点只需要扩展四周的点然后记录扩展的方向,如果方向相同那么边权就是0,方向不同边权就是1 注意vis数组也要开四个状态进行记录！！！
AtCoder Beginner Contest 254「E bfs」「F st表维护差分数组gcd」
Suryxin's blogs
06-30 453
AtCoder Beginner Contest 254「E bfs」「F st表维护差分数组gcd」
AtCoder Beginner Contest 168 C~D题解
天生我材必有用，千金散尽还复来。
05-19 7693
ABC168 C~D 题解 C - : (Colon) D - .. (Double Dots)
AtCoder Beginner Contest 184 F - Programming Contest 进制枚举+思维
kaka03200的博客
12-21 180
原题链接 文章目录题意分析 题意 给定n个物品，m是最大容量，求不超过最大容量的最大容量值。 分析 n范围是0到40，因此直接用二进制的枚举会超时，会达到240的时间复杂度。其中有一个小技巧，我们将物品分成两堆，然后进行枚举，最后会得到两堆的最优值。接着考虑合并两堆就可以了。 Max = max(Max, ai) Max = max(Max, ai + bi) 其中bi为可以取到的最优值，我们用二分去找就可以了。 #include <iostream> #include <cstring&
AtCoder练习
weixin_30537391的博客
07-23 277
1. 3721 Smuggling Marbles 大意: 给定$n+1$节点树, $0$为根节点, 初始在一些节点放一个石子, 然后按顺序进行如下操作. 若$0$节点有石子, 则移入盒子 所有石子移向父亲节点 把所有不少于$2$个石子的节点的石子丢掉 若树上还有石子,则返回第一步 对于所有$2^{n+1}$种初始放石子的方案, 求出最后盒子中石子总数之和. 长链...
AtCoder题解 —— AtCoder Beginner Contest 184 —— A - Determinant
努力中的老周的专栏
11-22 482
题目相关 题目链接 AtCoder Beginner Contest 184 A 题，https://atcoder.jp/contests/abc184/tasks/abc184_a。 Problem Statement Given is a 2×2 matrix ，The determinant of A can be found as ad−bc. Find it. Input Input is given from Standard Input in the following for
AtCoder Beginner Contest 184题解全
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
12-11 2438
AtCoder Beginner Contest 184 题目链接：https://atcoder.jp/contests/abc184/tasks 类似于牛客小白月赛，建议萌新们去体验一下，顺便复习四六级~ 还是一样的，代码分成主体和头文件两部分，头文件在文末。 A - Determinant 给你一个2*2的矩阵，输出它的行列式。 著名dreemoon说过，ABC的A题都是printf题。 const int MXN = 1e5 + 5; int n, m; int a, b, c, d; void
AtCoder Beginner Contest 134 简要题解
05-23
AtCoder Beginner Contest 134 是一场 AtCoder 的入门级比赛，以下是每道题的简要题解： A - Dodecagon 题目描述：已知一个正十二边形的边长，求它的面积。 解题思路：正十二边形的内角为 $150^\circ$，因此可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力的老周

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值