学习C++的第三周

一.sort排序

 1. 须加的头文件#include < algorithm>

2.Sort函数有三个参数：（第三个参数可不写）

（1）第一个是要排序的数组的起始地址。

（2）第二个是结束的地址（最后一位要排序的地址）

（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。

// 两个参数的模板如下

#include <iostream>
#include <algorithm>
int main()
{
 int a[20]={2,4,1,23,5,76,0,43,24,65},i;
 for(i=0;i<20;i++)
  cout<<a[i]<<endl;
 sort(a,a+20);
 for(i=0;i<20;i++)
 cout<<a[i]<<endl;
 return 0;
}

// 三个参数的模板如下（cmp 里决定了你的排序方式）

```#include<iostream>
 2 #include<algorithm>
 3 using namespace std;
 4 bool cmp(int a,int b)
 5 {
 6      return a>b;
 7 }
 8 int main()
 9 {
10      int a[10]={9,6,3,8,5,2,7,4,1,0};
11      for(int i=0;i<10;i++)
12      cout<<a[i]<<endl;
13      sort(a,a+10,cmp);
14
15      for(int i=0;i<10;i++)
16         cout<<a[i]<<endl;
17      return 0;
18 }

// 结构体里用这个也可以

bool cmp(node x,node y)
2 {
3    if(x.a!=y.a) return x.a<y.a;
4    if(x.b!=y.b) return x.b>y.b;
5    return x.c>y.c;
6 }
 

二.BDS与DFS的用法

1.用途区别：
DFS多用于连通性问题因为其运行思想与人脑的思维很相似，故解决连通性问题更自然。
BFS多用于解决最短路问题，其运行过程中需要储存每一层的信息，所以其运行时需要储存的信息量较大，如果人脑也可储存大量信息的话，理论上人脑也可运行BFS。

多数情况运行BFS所需的内存会大于DFS需要的内存(DFS一次访问一条路，BFS一次访问多条路)。

2.模板区别：
DFS
思想：一直往深处走，直到找到解或者走不下去为止.

算法步骤（递归或栈实现）
1.访问指定起始地点。
2.若当前访问顶点的邻接顶点有未被访问的顶点，就任选一个访问。如果没有就回退到最近访问的顶点，直到与起始顶点相通的所有点被遍历完。
3.若途中还有顶点未被访问，则再选一个点作为起始顶点。重复步骤2（针对非连通图）。

算法模板

BFS
算法思想
从某个点一直把其邻接点走完，然后任选一个邻接点把与之邻接的未被遍历的点走完，如此反复走完所有结点。类似于树的层序遍历。

算法步骤（用队列实现）
1.访问指定起始点。
2.访问当前顶点的邻接顶点有未被访问的顶点，并将之放入队列中。
3.删除队列的队首节点。访问当前队列的队首，重复步骤2。直到队列为空。
4.若若途中还有顶点未被访问，则再选一个点作为起始顶点。重复步骤2。（针对非连通图）。

算法模板

3.通过题目分析两者的用法

``

#include<iostream>
#include<queue>
#include<cstring> //string.h
using namespace std;

typedef pair<int,int> PII;

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

const int N = 25;
char g[N][N]; //存图的
int st[N][N]; //标记这个点有没有被搜过
int n,m; //n行m列
int res;

void bfs(int x,int y)
{
    queue<PII> q; 
    q.push({x,y});
    
    while(q.size() > 0) //队列不空 
    {
        PII t = q.front(); //取出队头
        q.pop();//出队
        
        for(int i=0; i<4; i++) //遍历四个方向
        {
            int a = t.first + dx[i], b = t.second + dy[i]; //队头邻接点的坐标
            if(a<0 || a>=n || b<0 || b>=m) continue; //出界
            if(st[a][b] == 1) continue; //已经被访问过
            if(g[a][b] != '.') continue; //不能走
            
            res++;
            q.push({a,b});
            st[a][b] = 1; //标记(a,b)已经被访问过
        }
    }
}


int main()
{
    while(cin >> m >> n)
    {
        if(m==0 && n==0) break;
        res = 1;
        memset(st,0,sizeof st); //memset(数组名,值,sizeof 数组名); 0/-1/0x3f
        
        for(int i=0; i<n; i++) cin >> g[i];
    
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
                if(g[i][j] == '@')
                {
                    bfs(i,j);
                    break;
                }
        cout << res << endl;        
    }
   

`

#include<iostream>
#include<cstring> //string.h
using namespace std;

typedef pair<int,int> PII;

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

const int N = 25;
char g[N][N]; //存图的
int st[N][N]; //标记这个点有没有被搜过
int n,m; //n行m列
int res;

void dfs(int x,int y)
{
    st[x][y] = 1; //标记被遍历
    for(int i=0; i<4; i++)
    {
        int a = x + dx[i], b = y + dy[i]; //邻接点的坐标
        if(a<0 || a>=n || b<0 || b>=m) continue; //出界
        if(st[a][b]) continue; //已经被访问过
        if(g[a][b] != '.') continue;
        
        res++;
        dfs(a,b);
    }
}


int main()
{
    while(cin >> m >> n)
    {
        if(m==0 && n==0) break;
        res = 1;
        memset(st,0,sizeof st); //memset(数组名,值,sizeof 数组名); 0/-1/0x3f
        
        for(int i=0; i<n; i++) cin >> g[i];
    
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
                if(g[i][j] == '@')
                {
                    dfs(i,j); 
                    break;
                }
        cout << res << endl;        
    }
    
}