感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐣🐣 python
🐓🐓🐓 数据结构C语言
🐔🐔🐔 C++
🐿️🐿️🐿️ 文章链接目录
🏀🏀🏀 笔试练习题

游游的you

链接游游的you

题目解析

这道题就是凑字符,从题目可以看到凑出you的时候得分为2,凑出oo的时候得分为1,注意oooo的得分为3,不是2

you的得分是oo的两倍,且you中各字符都只需要凑出1个就可以了,所以我们应该优先凑出you

oo这个字符串需要两个o,应该是最后剩下多余的o进行凑

解法

方法一贪心

int main() {
 int q,a,b,c,sum=0;
 cin>>q;
 while(q--)
 {
    cin>>a>>b>>c;
    int x=min(a,min(b,c));
    cout<<x*2+max(b-x-1,0)<<endl;
 }
 return 0;
}

这里用了两个函数min和max,min(a,min(b,c))最外面的min表示找出a和min(b,c)中最小的一个数,min(b,c)表示找出b和c中最小的一个数

最后打印是根据数学推导出来的,x*2表示的是凑出you的得分(x表示的是凑出you的个数)

max(b-x-1,0)是找出b-x-1和0中谁最大,如果b-x-1大于0那么就说明o还有多余的,剩余的o为b-x

当b-x=1的时候表示剩余的o为1,但是1-1=0,所以max最后为0

而当b-x>1的时候,我们以2为例,b-x-1=2-1=1,max(1,0)=1

方法二

#include <iostream>
using namespace std;

int main() {
	 int q,a,b,c,sum=0;
	 cin>>q;
	 for(int i=0;i<q;i++)
	 {
	    cin>>a>>b>>c;
		while(a&&b&&c)
		{
		    sum=sum+2;
		    a--;
		    b--;
		    c--;
		}
		if(b>1)
		{
		    sum=sum+b-1;
		}
		cout<<sum<<endl;
		sum=0;
	 }
 return 0;
}

腐烂的苹果

链接腐烂的苹果

题目解析

例子1

我们以这个图为例子

我们需要先找到一个腐烂的苹果,也就是2

经过一分钟后苹果向他的上下左右开始传播,被传播的苹果用绿色圆圈表示

之后被传播的苹果腐烂

第二分钟这些苹果又开始传播,由于中间没有苹果,所以中间不会被传播

之后的过程如下图所示

第三分钟

第四分钟

最后经过四分钟所以苹果都腐烂了,所以返回4

例子2

这个例子是永远有一个苹果不会被腐烂

先找出腐烂的苹果

第一分钟开始传播

传播后由于被传播的苹果附近没有苹果,导致无法继续传播,且这些格子内存在一个没有腐烂的苹果,所以最后返回-1

解法

多源BFS+最短路径

因为一开始可能不只有一个苹果是坏的,所以当不只有一个苹果的时候要让他们同一时刻都向他的上下左右扩散

所以需要将这三个苹果统一加到一个队列里,每次传播的时候都将队列里的所以元素都push出去,然后统一向外扩散

当扩散到最后一个苹果的时候,扩散的层数就是分钟数

因此我们需要用sz标记当前队列的元素,每次出堆的时候出sz个,然后用ret表示扩展了多少层,最后扩展完后遍历一遍数组,如果还有一个没有腐烂的苹果那么就返回-1

代码

class Solution {
int m,n;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
bool vis[1010][1010]={0};
public:
    int rotApple(vector<vector<int> >& grid) {
        n=grid.size(),m=grid[0].size();
        queue<pair<int,int>> q;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(grid[i][j]==2)
                {
                    q.push({i,j});
                }
            }
        }
          int ret=0;
                while(q.size())
                {
                    int sz=q.size();
                    ret++;
                    while(sz--)
                    {
                        auto[a,b]=q.front();
                        q.pop();
                        for(int i=0;i<4;i++)
                        {
                            int x=a+dx[i],y=b+dy[i];
                            if(x>=0&&x<n&&y>=0&&y<m&&grid[x][y]==1&&!vis[x][y])
                            {
                                vis[x][y]=true;
                                q.push({x,y});
                            }
                        }
                    } 
                }
                for(int i=0;i<n;i++)
                {
                    for(int j=0;j<m;j++)
                    {
                        if(grid[i][j]==1&&!vis[i][j])
                        return -1;
                    }
                }
                return ret-1;
    }
};

代码解析

因为要上下左右四个方向遍历搜索,和笔试练习day4的NC242 单词搜索一样,需要创建一个方向数组dx[4]={0,0,1,-1},dy[4]={1,-1,0,0}(这里我们可以总结出只要需要在上下左右四个方向搜索的题,我们都可以创建方向数组)

然后bool类型的数组vis记录该位置的是否已经遍历,当然我们也可以不用vis数组去标记,而是直接在原数组中将1改为2

m和n是表示二维数组grid有多少行和一行有多少个元素,q是一个队列,因为是记录的下标,所以是queue<pair<int,int>> q

因为是二维数组,所以要用两层循环去遍历去找grid[i][j]==2,如果找到了就push进q里

之后用ret去记录扩展了多少层,当队列不为空的时候就扩展一次,扩展的时候用sz去表示队列中有多少个元素

用 auto[a,b]=q.front()去得出队头元素的坐标(a,b),得到后pop

有了横纵坐标后就开始用方向数组去寻找他的上下左右是否有苹果,有苹果就让他变腐烂,并让腐烂的苹果push进队列,并修改vis[x][y]的bool值

当完全遍历完后我们需要用两层循环去查找是否还有没有腐烂的苹果,如果有就返回-1,没有就返回ret-1(因为扩展到最后一个苹果会将这个苹果坐标push进队列,然后再循环一次,但是这个苹果是最后一个,也就是ret++多了一次,所以最后要返回ret-1)

JZ62 孩子们的游戏(圆圈中最后剩下的数)

链接JZ62 孩子们的游戏(圆圈中最后剩下的数)

这个有点类似于约瑟夫问题

题目解析

我们以n=5 m=3为例子

刚开始从0报数

当报数为m-1也就是2的时候,2就要删除,并在2的下一个位置开始重新报数


这时3就应该报数0,4则报1,而0则报2,所以0要被删除

0的下一个位置是1,所以从1开始报数

这次4报的数为2,所以删除4


注意这时候虽然没有3个人了,但是因为是循环的,所以1报0后,3报1,最后1报2,所以最后应该删除1,留下3,因此返回3

解法

方法一模拟

这里我们只讲方法

环形链表模拟

这里的模拟是用环形链表去模拟实现的

每遍历到m-1个节点就删除那个节点,并让节点的前一个指向他的后一个

当删除到只有一个节点的时候,此时这个节点的下一个节点也是他自己,这时就直接返回节点的值

数组模拟

数组模拟就是创建一个长度为n的数组

这里需要注意一个问题就是当指针指向数组的最后一个元素的时候应该怎么回到起始位置

这里用的方法是当指针ptr已经指向超出数组范围的时候就让ptr的值模上5(我感觉有点怪,就是因为数组只有5个元素,既然ptr已经指向数组外了,那么就没有值,怎么就可以模n就可以回到原位置)

因为数组是不可以中间删除的,所以我们还需要创建一个bool类型的数组去用0和1表示是否删除元素

方法二递推/递归/动态规划

方法二选择用动态规划去做

状态表示

用dp[i]表示当有i个孩子围成一圈时最终获胜孩子的编号是多少
此时需要初始化dp[1]=0

状态转移方程

状态转移方程就是找出一个公式满足所有的dp[i]情况
比如状态转移方程可能是dp[i]=dp[i-1]+dp[i-2],当然也有可能是dp[i]=dp[i-1]+dp[i-2]+dp[i-3]…

下面是推导过程
假设有i个孩子,最后的孩子编号应该是i-1

我们需要删除第m个孩子,也就是编号为m-1,删除后从m开始

此时所以的编号都要更新,需要减m

但是因为编号不可能为负数,所以要在编号为负的所有孩子都加上i

这里的0更新后的编号应该是要比之前i-1大1的,所以i-1-m+1=i-m,所以-m要加上i才可以满足条件,因此要将所以负数都加上i才行

之前的m-1则是dp[i]

而现在里面的红色圆圈围成的圈表示有i-1个孩子参加游戏,最终获胜的孩子编号为dp[i-1]

注意下面这里有点绕
dp[i]和dp[i-1]存在这样的一个关系dp[i]=(dp[i-1]+m)%i

我来具体讲解一下为什么会有这个关系

左边我们可以看到内圈的编号都是比外圈的编号少一个m的,当dp[i-1]在左边的时候,我们是可以通过映射的方式去推导出dp[i]的,只需要让他加上m就可以得到编号了

当dp[i-1]在右边的时候,因为最后是要比左边多加一个i的,所以我们在dp[i-1]+m后还需要模一个i,
我们就那更新后编码为-2+i为例
先加上m就变成-2+i+m,之后(-2+i+m)%i=m-2,因为m-2小于i,所以余数就是m-2

所以dp[i]=(dp[i-1]+m)%i

有了这个式子我们就可以从dp[2]=(dp[1]+m)%2…这样一直往后推,直到推到dp[i]为止,虽然这样很绕,但是这个规律是存在的

代码

最后的代码非常简洁,但是那个公式是非常难推的

class Solution {
public:
    int LastRemaining_Solution(int n, int m) {
        int f=0;
            for(int i=2;i<=n;i++)
            {
                f=(f+m)%i;
            }
        return f;
    }
};