数据结构总结之dfs

1.大致就是：
2层for循环，循环!vis[i][j]的map[i][j],进行dfs，
在dfs中更新vis数组，dfs中，x < 0 || x >= n1 || y < 0 || y >= m || map_[x][y] != c||vis[x][y]都return ;
并在dfs中使得vis[x][y]=1;
最后用for循环遍历旁边的点，可以事先设置dxy[4][2] = {1,0,0,1,-1,0,0,-1};
模板题：
uva10336

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>

using namespace std;

int vis[100][100];
char map_[100][100];
int n1,m,T;
int  dxy[4][2] = {1,0,0,1,-1,0,0,-1};
struct node
{
    char c;
    int cnt;
    bool operator < (const node n)const
    {
        if(n.cnt==cnt) return c<n.c;
        else return cnt>n.cnt;
    }
} n[26];
void dfs( int x, int y,char c)
{

    if ( x < 0 || x >= n1 || y < 0 || y >= m || map_[x][y] != c)
        return;
    if(vis[x][y]) return ;
    vis[x][y]=1;
    for ( int i = 0 ; i < 4 ; ++ i )
        dfs( x+dxy[i][0], y+dxy[i][1],c);
}

int main()
{

    scanf("%d",&T);
    for ( int t = 1 ; t <= T ; ++ t )
    {
        for(int i=0; i<26; i++)
        {
            n[i].cnt=0;
            n[i].c='a'+i;
        }
        scanf("%d%d",&n1,&m);
        for ( int i = 0 ; i < n1 ; ++ i )
            scanf("%s",map_[i]);
        memset( vis, 0, sizeof(vis) );
        for(int i=0; i<n1; i++)
            for(int j=0; j<m; j++)
            {
                if(!vis[i][j])
                {
                    dfs(i,j,map_[i][j]);
                n[map_[i][j]-'a'].cnt++;
                }

            }

        printf("World #%d\n",t);
        sort(n,n+26);
        for(int i=0; i<26; i++)
            if(n[i].cnt) cout<<n[i].c<<": "<<n[i].cnt<<endl;
    }
    return 0;
}

2.tarjan算法求割点（去掉割点图就不是连通图）

#include <iostream>
#include <vector>
#include <stdio.h>
#include <string.h>
using namespace std;//放在vector之前
int n;//节点数
int count;//dfs为dfn编号的计数器
int ans;
int dfn[110];//遍历的顺序，也就是遍历的编号
int low[110];//记录节点u或u的子树可以追溯到的最早（dfn数最小，或者说是最早遍历的节点）的祖先节点
int rootson;//记录根节点的子树个数，大于1就代表根节点是割点
int f[110];//在dfs中记录下每个节点的父节点，根节点的父节点是0
bool cut[110];//判断是否为割点
vector<vector<int> > G;//代表图，G[i]里面存的是与i相连接的节点,还有注意要有个空格的语法问题：

void init()
{
    ans=0;
    count=0;
    G.clear();
    G.resize(n+1);//对于这种类似于二维数组的容器，要resize一下……
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(f,0,sizeof(f));
    memset(cut,0,sizeof(cut));
    rootson=0;
}
void tarjan(int u,int fa)//一种dfs算法
{
    dfn[u]=low[u]=++count;
    f[u]=fa;
    int len=G[u].size();
    for(int i=0;i<len;i++)
    {
        int v=G[u][i];
        if(!dfn[v])
        {
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
        }
        else if(fa!=v)
            low[u]=min(dfn[v],low[u]);
    }
}
int solve()
{
    tarjan(1,0);
    for(int i=2;i<=n;i++)
    {
        int v=f[i];
        if(v==1) rootson++;
        else if(dfn[v]<=low[i]) cut[v]=true;
    }
    for(int i=2;i<=n;i++)
        if(cut[i]) ans++;
    if(rootson>1) ans++;
    return ans;
}
 int main()
 {
     while(scanf("%d",&n),n)
     {
         init();
         int a,b;
         char ch;
         while(scanf("%d",&a),a)
         {
             while(scanf("%d%c",&b,&ch))
             {
                 G[b].push_back(a);
             G[a].push_back(b);
             if(ch=='\n') break;
             }
         }
         printf("%d\n",solve());
     }
     return 0;
 }

3.dfs的题目常常涉及到字符串和int数字的输入，以及输入输出格式问题，例如：
uva469

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

int t;
char map[110][110];
bool vis[110][110];
char tmp[110];
int dir[8][2]= {1,0,0,1,0,-1,-1,0,1,1,-1,1,-1,-1,1,-1};
int m,n;
int ans;
void dfs(int x,int y)
{
    vis[x][y]=1;
    for(int k=0; k<8; k++)
    {
        int dx=x+dir[k][0];
        int dy=y+dir[k][1];
        if(!vis[dx][dy] && dx>=0 && dx<m && dy>=0 && dy<n && map[dx][dy]=='W')
        {
            ans++;
            dfs(dx,dy);
        }
    }
}
int main()
{
    cin>>t;//cin没有把换行符提走，gets()提走了，scanf没有提走
    getchar();
    getchar();
    int end=0;
    while(t--)
    {
        m=0;
        n=0;
        if(end++) printf("\n");
        while(gets(map[m++]) && !(map[m-1][0]>='0' && map[m-1][0]<='9'));
        n=strlen(map[0]);
        m--;
        strcpy(tmp,map[m]);
        do
        {
            int x,y;
            if(strlen(tmp)==0) break;
            memset(vis,0,sizeof(vis));
            sscanf(tmp,"%d %d",&x,&y);
            ans=1;
            dfs(x-1,y-1);
            printf("%d\n",ans);

        }
        while(gets(tmp));

    }
    return 0;
}

4.看这种dfs：uva1867

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
using namespace std;
int n;
bool map[110][110];//记录j是否是i的依赖点
int ans[110];//每个点的依赖点数目，一旦赋值就不会变，因为我们是倒着求ans值的，也就是从最少的点开始……
int dfs(int i)//返回节点i的依赖点，由于没有环形，所以一个点不可能即是间接依赖点又是直接依赖点
{
    if(ans[i]) return ans[i];
    int Max=0;
    for(int j=1;j<=n;j++)
    if(map[i][j])
        Max=max(Max,dfs(j)+1);
    ans[i]=Max;
    return Max;
}
int main()
{
    while(scanf("%d",&n),n)
    {
        memset(map,0,sizeof(map));
        memset(ans,0,sizeof(ans));
        for(int i=1;i<=n;i++)
        {
            int t;scanf("%d",&t);
            for(int j=0;j<t;j++)
            {
                int a;
                scanf("%d",&a);
                map[i][a]=1;
            }
            map[0][i]=1;//假设节点0与所有节点有依赖关系，我们要构造一个树，那么0就是树根
        }
        dfs(0);
        int ans_=1;
        for(int i=2;i<=n;i++)
        {
            if(ans[i]>ans[ans_]) ans_=i;

        }
        printf("%d\n",ans_);
    }
    return 0;
}

dfs（int x）遍历和x有关的点，ans=max(ans,dfs(next y)+1;但要注意：这里ans也有vis数组的功能