【PAT甲级笔记】图类型题及题解

图和最短路径的题目常常伴随着dfs，bfs的搜索方法进行。

图的题目，很大程度为求对应的图的连通分量

DFS深度优先搜索：

void dfs()//参数用来表示状态
{
    if(到达终点状态)
    {
        ...//根据题意来添加
        return;
    }
    if(越界或者是不符合法状态)
        return;
    for(扩展方式)
    {
        if(扩展方式所达到状态合法)
        {
            ....//根据题意来添加
            标记；
            dfs（）；
            修改（剪枝）；
            (还原标记)；
            //是否还原标记根据题意
            //如果加上（还原标记）就是 回溯法
        }
        
    }
}

• 在进行dfs时，传入的参数尽量为int形等变量（当传入struct等类型，容易产生段错误，可以通过传入结构体对应的索引来进行解决。）

BFS

需要使用队列进行相应的操作，在求层序遍历时用处更大。

tips:强连通分量的dfs题目

1013 Battle Over Cities (25分)

#include<algorithm>
#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<cmath>

using namespace std;
int n,m,k,occu;

int e[1010][1010];
bool visit[1010];


void dfs(int index)
{
    visit[index]=true;
    for(int i=1;i<=n;i++)
        if(visit[i]==false && e[index][i]==1)
            dfs(i);
}

int main()
{
    int a,b,num;
    scanf("%d%d%d", &n, &m, &k);
    for(int i=0;i<m;i++)
       {
           scanf("%d %d",&a, &b);
           e[a][b]= e[b][a]=1;
       }
    for(int j=0;j<k;j++)
    {
        fill(visit, visit+1010, false);
        num=0;

        scanf("%d", &occu);
        visit[occu]=true;
        for(int i=1;i<=n;i++)
            if(visit[i]==false)
        {
            dfs(i);
            num++;
        }
        printf("%d\n", num-1);
    }

    return 0;
}

1091. Acute Stroke 图的三维DFS

技巧：将三个方向上的位移用dx,dy,dz三个数组表示

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

这样在求解连通的方块的时候可以使用一个for循环解决

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
int m,n,l,t;
int a[1287][130][61];
bool visit[1287][130][61];
struct node
{
    int x,y,z;
};
int dx[6] = {1,-1,0,0,0,0};
int dy[6] = {0,0,1,-1,0,0};
int dz[6] = {0,0,0,0,1,-1};
int dfs(int x,int y,int z)
{
    int score=0;
    queue<node> st;
    visit[x][y][z]=true;
    st.push({x,y,z});
    while(!st.empty())
    {
        node nod = st.front();
        score++;
        st.pop();
        for(int i=0;i<6;i++)
        {
        int tx=nod.x+dx[i];
        int ty=nod.y+dy[i];
        int tz=nod.z+dz[i];
        if(tx<m&&ty<n&&tz<l&&tx>=0&&ty>=0&&tz>=0)
            if(visit[tx][ty][tz]==false&& a[tx][ty][tz]==1)
               {
                 st.push({tx,ty,tz}); visit[tx][ty][tz]=true;
               }
        }
    }
    if(score>=t) return score;
    else return 0;
}

int main()
{
    scanf("%d %d %d %d",&m, &n, &l, &t);
    for(int i=0;i<l;i++)
        for(int k=0;k<m;k++)
            for(int j=0;j<n;j++)
                scanf("%d", &a[k][j][i]);
    int ant=0;
    for(int i=0;i<l;i++)
        for(int k=0;k<m;k++)
            for(int j=0;j<n;j++)
                if(visit[k][j][i]==false&& a[k][j][i]==1)
                {
                    ant+=dfs(k,j,i);
                }
    cout<<ant<<endl;
   return 0;
}

1103 Integer Factorization

这里有个思想：穷举法暴力模拟，为了避免超时，一般都把待选数放到一个数组里，而不是每次重新计算。
这个题用搜素也是我没想到的，原来以为要用暴力，感觉是个数学题的缘故，以为要用什么巧…