DFS的一些题目整理

整理了一下做过的dfs的问题 

关于dfs递归写法：我一般都是把它想成一个n叉树，然后一直dfs（i+1) 进行延申，一直到结点的边界。先考虑一条路线，一般使用flag数组进行标记，用path数组保存路径上的信息 ，不要忘了加上一个结点返回的条件。总之path数组是最关键的，它保存了路径的信息，而迷宫问题和选数问题一般需要标记flag数组来控制函数不让它访问已经访问过的结点。

递归明白一点就行，思考递归时，思考两层递归就可以，dfs(i+1)结束之后会返回dfs(i)。

1 全排列问题：

题目描述
输出自然数1到n所有不重复的排列，即n的全排列，要求所产生的任一数字序列中不允许出现重复的数字。

输入输出格式
输入格式：

n(1≤n≤9)

输出格式：

由1～n组成的所有不重复的数字序列，每行一个序列。每个数字保留5个常宽。

输入输出样例
输入样例#1： 

3
输出样例#1： 

    1    2    3
    1    3    2
    2    1    3
    2    3    1
    3    1    2
    3    2    1

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int flag[10];
int path[10];
int n;
void dfs(int i)
{
    int j;
    if(i==n+1)
    {
        int k;
        for(k=1;k<=n;k++)
        {
            printf("%d ",path[k]);
        }
        printf("\n");
    }
    else
    {
        for(j=1;j<=n;j++)
        {
            if(flag[j]==0)
            {
                path[i]=j;
                flag[j]=1;
                dfs(i+1);
                flag[j]=0;
            }
        }
    }
}
int main()
{
    memset(flag,0,sizeof(flag));
    memset(path,0,sizeof(path));
    scanf("%d",&n);
    dfs(1);
}

2 油田问题：
GeoSurvComp地质调查公司负责探测地下石油储藏。 GeoSurvComp现在在一块矩形区域探测石油，并把这个大区域分成了很多小块。他们通过专业设备，来分析每个小块中是否蕴藏石油。如果这些蕴藏石油的小方格相邻，那么他们被认为是同一油藏的一部分。在这块矩形区域，可能有很多油藏。你的任务是确定有多少不同的油藏。
Input
输入可能有多个矩形区域（即可能有多组测试）。每个矩形区域的起始行包含m和n，表示行和列的数量，1<=n,m<=100，如果m =0表示输入的结束，接下来是n行，每行m个字符。每个字符对应一个小方格，并且要么是’*’，代表没有油，要么是’@’，表示有油。
Output
对于每一个矩形区域，输出油藏的数量。两个小方格是相邻的，当且仅当他们水平或者垂直或者对角线相邻（即8个方向）。
Sample Input

1 1
*
3 5
@@*
@
@@*
1 8
@@*@
5 5
*@@@@@@@
@@@@ @@*@

Sample Output
0
1
2
2

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

char a[105][105];
int n,m,result;
int d[8][2]={{1,0},{-1,0},{0,1},{0,-1},{1,1},{-1,-1},{1,-1},{-1,1}};

int check(int x,int y)
{
    if(x>=0&&x<m&&y>=0&&y<n&&a[x][y]=='@')
        return 1;
    return 0;
}

int dfs(int x, int y)
{
    int i,xx,yy;
    if(check(x,y))
    {
        a[x][y]='.';

        for(i=0;i<8;i++)
        {
            xx=x+d[i][0];
            yy=y+d[i][1];
            dfs(xx,yy);
        }
        return 1;
    }
    return 0;
}

int main()
{
    int i,j;
    while(~scanf("%d %d",&m,&n))
    {
        if(m==0&&n==0)
            break;
        result = 0;
        memset(a,0,sizeof(a));
        for(i=0;i<m;i++)
            scanf("%s",a[i]);
        for(i=0;i<m;i++)
        {
            for(j=0;j<n;j++)
            {
                if(dfs(i,j))
                    result++;
            }
        }
        printf("%d\n",result);
    }
}

 3 整数分解为若干项之和：

将一个正整数N分解成几个正整数相加，可以有多种分解方法，例如7=6+1，7=5+2，7=5+1+1，…。编程求出正整数N的所有整数分解式子。

输入格式：

每个输入包含一个测试用例，即正整数N (0<N≤30)。

输出格式：

按递增顺序输出N的所有整数分解式子。递增顺序是指：对于两个分解序列N​1​​={n​1​​,n​2​​,⋯}和N​2​​={m​1​​,m​2​​,⋯}，若存在i使得n​1​​=m​1​​,⋯,n​i​​=m​i​​，但是n​i+1​​<m​i+1​​,则N​1​​序列必定在N​2​​序列之前输出。每个式子由小到大相加，式子间用分号隔开，且每输出4个式子后换行。

输入样例：

7

输出样例：

7=1+1+1+1+1+1+1;7=1+1+1+1+1+2;7=1+1+1+1+3;7=1+1+1+2+2
7=1+1+1+4;7=1+1+2+3;7=1+1+5;7=1+2+2+2
7=1+2+4;7=1+3+3;7=1+6;7=2+2+3
7=2+5;7=3+4;7=7

#include<stdio.h>
int path[100];
int sum=0;
int n;
int count=0;

void dfs(int i)
{
    int j,k;
    if(sum==n)
    {
        count++;
        printf("%d=",n);
        for(k=1; k<=i-1; k++)
        {
            if(k==i-1)
            {
                if(count==4)
                {
                    count=0;
                    printf("%d\n",path[k]);
                }
                else
                {
                    if(path[1]==n) printf("%d",path[k]);
                    else printf("%d;",path[k]);
                }
            }
            else
                printf("%d+",path[k]);
        }
    }
    else
    {
        for(j=1; j<=n; j++)
        {
            if(sum+j<=n && j>=path[i-1]) //这里要保证后一个数不能比path的前一个数小并且不能超过sum
            {
                path[i]=j;
                sum+=j;
                dfs(i+1);
                sum-=j;
            }
        }
    }
}
int main()
{
    memset(path,0,sizeof(path));
    scanf("%d",&n);
    dfs(1);
}

4 迷宫问题：

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。Output左上角到右下角的最短路径，格式如样例所示。Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output

(1, 1) (2, 1) (3, 1) (3, 2) (3, 3) (3, 4) (3, 5) (4, 5) (5, 5)

#include<stdio.h>
int a[100][100],n;
int path[200][2];
int min[200][2],min_=100;
int flag[100][100]= {0};
int dir[4][2]= {{0,-1},{0,1},{-1,0},{1,0}};

void dfs(int x,int y,int i)
{
    int k,j;
    if(x==n && y==n)
    {
        if(i<min_)
        {
            min_=i;

            for(j=1;j<i;j++)
            {
                min[j][0] = path[j][0];
                min[j][1] = path[j][1];
            }
        }
    }
    else
    {
        flag[x][y]=1;
        for(k=0; k<4; k++)
        {
            if( a[x+dir[k][0]][y+dir[k][1]] == 0 && flag[x+dir[k][0]][y+dir[k][1]] == 0 && (x+dir[k][0]<=n && x+dir[k][0]>=1) && (y+dir[k][1]<=n && y+dir[k][1]>=1))
            {
                path[i][0] = x+dir[k][0];
                path[i][1] = y+dir[k][1];

                dfs(x+dir[k][0], y+dir[k][1], i+1);

                flag[x+dir[k][0]][y+dir[k][1]] = 0;
            }
        }
    }
}
int main()
{
    int i,j;
    scanf("%d ",&n);
    for(i=1; i<=n; i++)
    {
        for(j=1; j<=n; j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    dfs(1,1,1);

    min[0][0]=1;min[0][1]=1;
    for(i=0; i<min_; i++)
    {
        printf("(%d, %d) ",min[i][0],min[i][1]);
    }
}