算法刷题day07

引言

今天就是搞双指针跟BFS的，这个都是最基础的题啊，所以看着没那么难，之后会找题去写的，然后就这样吧。

---

一、日志统计

标签：双指针算法

思路：一般这种思路就是遍历日志/订单，然后用双指针，终点从0开始动，然后判断起点到终点的时间段是否满足，不满足那就指针前移，相应的东西就要减，最后判断是否满足条件

题目描述：

小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 N 行。

其中每一行的格式是：
ts id  表示在 ts 时刻编号 id 的帖子收到一个”赞”。

现在小明想统计有哪些帖子曾经是”热帖”。

如果一个帖子曾在任意一个长度为 D 的时间段内收到不少于 K 个赞，小明就认为这个帖子曾是”热帖”。

具体来说，如果存在某个时刻 T 满足该帖在 [T,T+D) 这段时间内(注意是左闭右开区间)收到不少于 K 个赞，该帖就曾是”热帖”。

给定日志，请你帮助小明统计出所有曾是”热帖”的帖子编号。

输入格式
第一行包含三个整数 N,D,K。

以下 N 行每行一条日志，包含两个整数 ts 和 id。

输出格式
按从小到大的顺序输出热帖 id。

每个 id 占一行。

数据范围
1≤K≤N≤105,0≤ts,id≤105,1≤D≤10000
输入样例：
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
输出样例：
1
3

示例代码：

#include 
#include 
#include 

using namespace std;

typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1e5+10;

int n, d, k;
int cnt[N];
bool st[N];
PII logs[N];

int main()
{
    scanf("%d%d%d", &n, &d, &k);
    for(int i = 0; i < n; ++i) scanf("%d%d", &logs[i].x, &logs[i].y);
    
    sort(logs, logs+n);
    
    for(int i = 0, j = 0; j < n; ++j)
    {
        int id = logs[j].y;
        cnt[id]++;
        
        while(logs[j].x - logs[i].x >= d)
        {
            cnt[logs[i].y]--;
            i++;
        }
        
        if(cnt[id] >= k) st[id] = true;
    }
    
    for(int i = 0; i < N; ++i) if(st[i]) printf("%d\n", i);
    
    return 0;
}

---

二、 献给阿尔吉侬的花束

标签：BFS

思路：就是一个bfs模板，熟练应用就行

题目描述：

阿尔吉侬是一只聪明又慵懒的小白鼠，它最擅长的就是走各种各样的迷宫。

今天它要挑战一个非常大的迷宫，研究员们为了鼓励阿尔吉侬尽快到达终点，就在终点放了一块阿尔吉侬最喜欢的奶酪。

现在研究员们想知道，如果阿尔吉侬足够聪明，它最少需要多少时间就能吃到奶酪。

迷宫用一个 R×C 的字符矩阵来表示。

字符 S 表示阿尔吉侬所在的位置，字符 E 表示奶酪所在的位置，字符 # 表示墙壁，字符 . 表示可以通行。

阿尔吉侬在 1 个单位时间内可以从当前的位置走到它上下左右四个方向上的任意一个位置，但不能走出地图边界。

输入格式
第一行是一个正整数 T，表示一共有 T 组数据。

每一组数据的第一行包含了两个用空格分开的正整数 R 和 C，表示地图是一个 R×C 的矩阵。

接下来的 R 行描述了地图的具体内容，每一行包含了 C 个字符。字符含义如题目描述中所述。保证有且仅有一个 S 和 E。

输出格式
对于每一组数据，输出阿尔吉侬吃到奶酪的最少单位时间。

若阿尔吉侬无法吃到奶酪，则输出“oop!”（只输出引号里面的内容，不输出引号）。

每组数据的输出结果占一行。

数据范围
1<T≤10
,
2≤R,C≤200
输入样例：
3
3 4
.S..
###.
..E.
3 4
.S..
.E..
....
3 4
.S..
####
..E.
输出样例：
5
1
oop!

示例代码：

#include 
#include 
#include 

using namespace std;

typedef pair<int,int> PII;
#define x first
#define y second

const int N = 210;

int n;
int r, c;
char g[N][N];
PII start, e;
PII q[N*N];
int dist[N][N];

int dir[4][2] = {0,1,0,-1,1,0,-1,0};

int bfs()
{
    memset(dist, -1, sizeof dist);
    dist[start.x][start.y] = 0;
    
    int hh = 0, tt = -1;
    q[++tt] = start;
    while(hh <= tt)
    {
        auto t = q[hh++];
        for(int i = 0; i < 4; ++i)
        {
            int x = t.x + dir[i][0];
            int y = t.y + dir[i][1];
            
            if(x < 0 || x >= r || y < 0 || y >= c) continue;
            if(dist[x][y] != -1 || g[x][y] == '#') continue;
            
            dist[x][y] = dist[t.x][t.y] + 1;
            q[++tt] = {x,y};
            
            if(g[x][y] == 'E') return dist[x][y];
        }
    }
    
    return -1;
}

int main()
{
    scanf("%d", &n);
    
    while(n--)
    {
        scanf("%d%d", &r, &c);
        for(int i = 0; i < r; ++i) scanf("%s", g[i]);
        
        for(int i = 0; i < r; ++i)
        {
            for(int j = 0; j < c; ++j)
            {
                if(g[i][j] == 'S') start = {i,j};
                if(g[i][j] == 'E') e = {i,j};
            }
        }
        
        int res = bfs();
        
        if(res == -1) puts("oop!");
        else printf("%d\n", res);
    }
    
    return 0;
}

---

三、红与黑

标签：BFS

思路：没什么说的BFS模板，然后就是输入的先是列数再是行数，这个把我坑了，看了半天呢，要仔细看题，不要想当然

题目描述：

有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。

你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。

请写一个程序，计算你总共能够到达多少块黑色的瓷砖。

输入格式
输入包括多个数据集合。

每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。

在接下来的 H 行中，每行包括 W个字符。每个字符表示一块瓷砖的颜色，规则如下

1）‘.’：黑色的瓷砖；
2）‘#’：红色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。

当在一行中读入的是两个零时，表示输入结束。

输出格式
对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

数据范围
1≤W,H≤20
输入样例：
6 9 
....#. 
.....# 
...... 
...... 
...... 
...... 
...... 
#@...# 
.#..#. 
0 0
输出样例：
45

示例代码：

#include 
#include 
#include 

using namespace std;

typedef pair<int,int> PII;
#define x first
#define y second

const int N = 30;

int r, c;
char g[N][N];
bool st[N][N];
PII start;
PII q[N*N];

int dir[4][2] = {0,1,0,-1,1,0,-1,0};

int bfs()
{
    memset(st, 0, sizeof st);  //可以不写但习惯别漏就行
    st[start.x][start.y] = true;
    
    int res = 1;
    int hh = 0, tt = -1;
    q[++tt] = start;
    while(hh <= tt)
    {
        auto t = q[hh++];
        for(int i = 0; i < 4; ++i)
        {
            int x = t.x + dir[i][0];
            int y = t.y + dir[i][1];
            
            if(x < 0 || x >= r || y < 0 || y >= c) continue;
            if(st[x][y] || g[x][y] == '#') continue;
            
            st[x][y] = true;
            res++;
            q[++tt] = {x,y};
        }
    }
    
    return res;
}

int main()
{
    while(1)
    {
        scanf("%d%d", &c, &r);
        if(r == 0 || c == 0) break;
        
        for(int i = 0; i < r; ++i) scanf("%s", g[i]);
        
        for(int i = 0; i < r; ++i)
        {
            for(int j = 0; j < c; ++j)
            {
                if(g[i][j] == '@')
                {
                    start = {i,j};
                    break;
                }
            }
        }
        
        int res = bfs();
        
        printf("%d\n", res);
        
        //exit(0);
    }
    
    return 0;
}

---

四、交换瓶子

标签：枚举

思路：就是找瓶子对应的下标，交换一下就行了

题目描述：

有 N 个瓶子，编号 1∼N，放在架子上。

比如有 5 个瓶子：

2 1 3 5 4
要求每次拿起 2 个瓶子，交换它们的位置。

经过若干次后，使得瓶子的序号为：

1 2 3 4 5
对于这么简单的情况，显然，至少需要交换 2 次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式
第一行包含一个整数 N，表示瓶子数量。

第二行包含 N 个整数，表示瓶子目前的排列状况。

输出格式
输出一个正整数，表示至少交换多少次，才能完成排序。

数据范围
1≤N≤10000,

输入样例1：
5
3 1 2 5 4
输出样例1：
3
输入样例2：
5
5 4 3 2 1
输出样例2：
2

示例代码：

#include 
#include 
#include 

using namespace std;

const int N = 1e4+10;

int id[N];  //瓶子号对应的下标
int a[N];  //下标对应的瓶子编号

int main()
{
    int n;
    scanf("%d", &n);
    
    for(int i = 1; i <= n; ++i) 
    {
        int t;
        scanf("%d", &t);
        id[t] = i;
        a[i] = t;
    }
    
    // 1 2 3 4 5 i
    // 5 4 3 2 1 a[i]
    int res = 0;
    for(int i = 1; i <= n; ++i)
    {
        if(i != a[i])
        {
            int t = id[i];
            swap(id[i], id[a[i]]);
            swap(a[i], a[t]);
            res += 1;
        }
    }
    
    printf("%d\n", res);
    
    return 0;
}

---

五、总结

• 如果在图论中#define x first，那么在定义x的时候，其实也没问题，因为你发现就算把x替换为first，那么也不会出现问题，除非你在作用域中有一个变量first，当然一般不会这么命名，所以就放心的用