1、找到最多的数
记录一下好的思路：

//1、或者把二维数组存成一维数组，进行排序，因为一个数出现次数超过一半则中间那个数一定就是它了
//2、使用map实现每个数和每个数出现次数的映射
#include <iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;
const int N =1e3+10;
//int M[N][N];
int m,n;
unordered_map<int,int>p;
int main()
{
  scanf("%d%d",&n,&m);
  for(int i=0;i<n;i++)
     for(int j=0;j<m;j++)
  {   //cin>>M[i][j];
      int x;
      cin>>x;
      p[x]++;
  }
  //for(int i=0;i<p.size();i++)
  //if(p[i]>n*m/2) cout<<i<<endl;
  for(auto [x,y]:p){
    if(2*y>m*n){
    cout<<x<<endl;
    break;
  }
  }
  return 0;
}

2、旋转矩阵问题，将一个矩阵旋转90度，原来坐标为[i,j]的点会变化为[j,n+1-i],再开一个矩阵存下来就可以了

S[j,n+1-i]=M[i,j]

3、穿越雷区（经典bfs问题）
就是输入的时候用一维输入会输入不进去很奇怪，必须两层循环才可以输入，题目中要求交替走，那么只需要判断一下前后两步走的字符是否相同就可以了

#include <iostream>
#include<algorithm> 
#include <queue>
#include <cstring>
#define x first
#define y second
using namespace std;
const int N=110;
typedef pair<int,int> PII;
char M [N][N];
int n;
int ax,ay;
int bx,by;
int dist[N][N];//记录A点到各个点的距离
queue<PII> q;//q里面存的是坐标
bool st[N][N];//是否访问过的标记
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int bfs(int x,int y){
  memset(dist,0x3f,sizeof dist);
      dist[x][y]=0;
      st[x][y]=true;
      q.push({x,y});//&&&&&&&&&&&&&& 3步
      while(q.size()){
        PII t=q.front();
        q.pop();
        int distance=dist[t.x][t.y];
        if(M[t.x][t.y]=='B')
        return distance;
       for(int i=0;i<4;i++){
         int a=t.x+dx[i];  //&&&&&&&&&&&要在取出来的点t的基础上进行上下左右找点
         int b=t.y+dy[i];
        if(a<0||a>=n||b<0||b>=n||st[a][b])continue;
     //其实交替走的话也就是判断前后走的符号相同不相同，不相同才能走啊
        if(M[a][b]==M[t.x][t.y])continue;
        dist[a][b]=distance+1;
        q.push({a,b});
        //&&&&&&&&&&&&&&状态数组不要忘记变化
        st[a][b]=true;
       }
      }
}
int main()
{
  scanf("%d",&n);
  for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
    {
      cin>>M[i][j];
  //&&&&&&&&&&&&&&&&&&输入最好用二维输入
      if(M[i][j]=='A')
      ax=i,ay=j;    //也可以在输入的时候直接找到
    }
  int distance=bfs(ax,ay);
  if(distance==0x3f3f3f3f)
  cout<<'-1'<<endl;
  else
  cout<<distance<<endl;
  return 0;
}

4、小蓝的漆房
呜呜，这上面浪费好长时间，发现问题：
1、vector数组按下标方式可以访问，但不能修改值（反正我这样做是错的）
2、枚举所有颜色对应的最少粉刷次数，可以不用存下来，直接每次取一个min就可以，反正最后要的只有最小值一个数
3、模拟粉刷墙的过程：（不会模拟呜呜呜，看了题解才知道咋模拟）
碰见颜色一样的就跳过，碰见不一样颜色的就刷，（往后数我最多能刷的长度）

//枚举的话我就枚举每一种颜色，然后求出每一种所需要的天数，找出最小值

#include <iostream>
#include <algorithm>
#include <vector>
#include<cstring>
using namespace std;
const int N=1e4+10;
int t,n,k;
int a[N];
bool st[N];
//实现每种颜色需要最少天数的计算
//模拟这个过程不会啊啊啊啊啊啊啊服了我自己呜呜呜无语呜呜
int main()
{
 scanf("%d",&t);
 while(t--){
   memset(st,false,sizeof st);
   scanf("%d%d",&n,&k);
   for(int i=0;i<n;i++)
   { scanf("%d",&a[i]);
     st[a[i]]=true;//记录用到了那种颜色
   }
   int minn=100000;  //需要的最大天数绝对不超过n,足够大就可以
  for(int i=1;i<=60;i++){
     if(st[i]==false) continue;
     int sum=0;
     for(int j=0;j<n;j++)//从第一面墙开始枚举
     {

          if(a[j]==i) continue;
          sum++;//选择每种颜色所需要的天数不需要存在来，每次比较一下取最小值就可以
        //  c[i]=c[i]+1;//这种做法是错误的！！！！！！！
//对于vector数组，下标只能用于获取已存在的元素，而现在的c[i]还是空的对象

         // cout<<c[i]<<endl;
          j=j+k-1;//因为后面j++
     }
     minn=min(minn,sum);
  }
  cout<<minn<<endl;
 }
  return 0;
}