图（领接矩阵和vector）的dfs和bfs

最新推荐文章于 2022-07-21 20:14:31 发布
最新推荐文章于 2022-07-21 20:14:31 发布
阅读量549 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33785671/article/details/52647728
版权

//Uva572 图的dfs求连通块

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int m,n;
int dir[8][2] = {{-1,0},{-1,1},{0,1},{1,1},
                 { 1,0},{1,-1},{0,-1},{-1,-1}};
bool vis[105][105];
char map[105][105];

void dfs(int x, int y){
    for(int i=0; i<8; ++i){
        int dx=x+dir[i][0], dy=y+dir[i][1];
        if(dx>=0 && dx<m && dy>=0 && dy<n && map[dx][dy]=='@' && !vis[dx][dy]){
            vis[dx][dy] = true;
            dfs(dx, dy);
        }
    }
}

int main(){
#ifdef LOCAL
    freopen("input.txt","r",stdin);
#endif
    int i,j;
    while(scanf("%d %d%*c",&m,&n) && m && n){
        for(i=0; i<m; ++i)
            gets(map[i]);
        memset(vis, 0, sizeof(vis));
        int cnt=0;
        for(i=0; i<m; ++i){
            for(j=0; j<n; ++j){
                if(map[i][j]=='@' && !vis[i][j]){
                    ++cnt;
                    dfs(i, j);
                }
            }
        }
        printf("%d\n",cnt);
    }   
    
    return 0;
}


//Uva1103

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <vector>
#include <set>

using namespace std;

const int MAXH = 210;
const int MAXW = 100;

int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
char* bin[]= {"0000","0001","0010","0011","0100","0101","0110","0111",
            "1000","1001","1010","1011","1100","1101","1110","1111"};
char code[] = "WAKJSD";

int W,H;
char pic1[MAXH][MAXW];
char pic[MAXH][MAXW<<2];
int color[MAXH][MAXW<<2];

void dfs(int x, int y, int col)
{
    color[x][y] = col;
    for(int i = 0; i < 4; ++i){
        int xx = x + dx[i], yy = y + dy[i];
        if(xx >= 0 && xx < H && yy >= 0 && yy < W
           && pic[x][y] == pic[xx][yy] && !color[xx][yy]){
            dfs(xx,yy,col);
           }
    }
}

int main(void)
{
    //freopen("input.txt","r",stdin);
    int cas = 1;
    while(scanf("%d %d", &H, &W), H || W){

        memset(pic,0,sizeof(pic));
        memset(color,0,sizeof(color));

        for(int i = 0; i < H; ++i)
            scanf("%s",pic1[i]);
        for(int i = 0 ; i < H; ++i){
            for(int j = 0; j < W; ++j){
                if(isdigit(pic1[i][j]))
                    pic1[i][j] -= '0';
                else
                    pic1[i][j] -= 'a' - 10;
                for(int k = 0; k < 4; ++k)
                    pic[i+1][1 + 4 * j + k] = bin[pic1[i][j]][k] - '0';
            }
        }

        H += 2;
        W = 4 * W + 2;
        int cnt = 0;
        vector<int> cc;
        for(int i = 0; i < H; ++i){
            for(int j = 0; j < W; ++j){
                if(!color[i][j]){
                    dfs(i,j,++cnt);
                    if(pic[i][j] == 1) cc.push_back(cnt);
                }
            }
        }

        vector<set<int> > neigh(cnt+1);
        for(int i = 0; i < H; ++i){
            for(int j = 0; j < W; ++j){
               if(pic[i][j]){
                    for(int k = 0; k < 4; ++k){
                        int x = i + dx[k], y = j + dy[k];
                        if(x >= 0 && x < H && y >= 0 && y < W &&
                           pic[x][y] == 0 && color[x][y] != 1)
                            neigh[color[i][j]].insert(color[x][y]);
                    }
                }
            }
        }

        vector<char> ans;
        for(int i = 0, sz = cc.size(); i < sz; ++i)
            ans.push_back(code[neigh[cc[i]].size()]);
        sort(ans.begin(),ans.end());

        printf("Case %d: ",cas++);
        for(int i = 0, sz = ans.size(); i < sz; ++i)
            printf("%c",ans[i]);
        puts("");

    }
    return 0;
}

//图的bfs求最短路

#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;

struct note
{
  int r;
  int c;
  int dir;
};
string s,s1;
int r0,c0,r1,c1,dir,r2,c2;
int has_edge[10][10][4][3];
int d[10][10][4];
note p[10][10][4];
char dirs[]={'N','E','S','W'};
char turns[]={'F','L','R'};
int dr[]={-1,0,1,0};
int dc[]={0,1,0,-1};

note walk(note u,int turn)
{
  note v;
  int dirr=u.dir;
  if(turn==1) {dirr=(dirr+3)%4;}
  if(turn==2) {dirr=(dirr+1)%4;}
  v.r=u.r+dr[dirr];
  v.c=u.c+dc[dirr];
  v.dir=dirr;
  return v;
}
bool inside(int x,int y)
{
  if(x>=1&&x<=9&&y>=1&&y<=9) return true;
  return false;
}
void print_ans(note u)
{
  vector<note> vec;
  while(1)
  {
    if(d[u.r][u.c][u.dir]==0) break;
    vec.push_back(u);
    u=p[u.r][u.c][u.dir];
  }
  u.r=r0;u.c=c0;u.dir=dir;
  vec.push_back(u);
  cout<<s1<<endl;
  int cnt=0;
  for(int i=vec.size()-1;i>=0;i--)
  {
    cnt++;
    if(cnt==1) printf("  ");
    printf("(%d,%d)",vec[i].r,vec[i].c);
    if(cnt!=10&&i!=0) printf(" ");
    if(cnt==10&&i!=0) {printf("\n");cnt=0;}
  }
  printf("\n");
}
void solve()
{
  queue<note> q;
  note uu;
  uu.r=r0;uu.c=c0;uu.dir=dir;
  note u;
  u.r=r1;u.c=c1;u.dir=dir;
  d[r1][c1][dir]=1;
  p[r1][c1][dir]=uu;
  d[r0][c0][dir]=0;
  q.push(u);
  while(!q.empty())
  {
    u=q.front();
    q.pop();
    if(u.r==r2&&u.c==c2) {print_ans(u);return;}
    for(int i=0;i<3;i++)
    {
      note v=walk(u,i);
      if(has_edge[u.r][u.c][u.dir][i]&&inside(v.r,v.c)&&d[v.r][v.c][v.dir]<0)
      {
        p[v.r][v.c][v.dir]=u;
        d[v.r][v.c][v.dir]=d[u.r][u.c][u.dir]+1;
        q.push(v);
      }
    }
  }
  cout<<s1<<endl;
  printf("  No Solution Possible\n");
}

int main()
{
  while(cin>>s1)
  {
    if(s1=="END") break;
    memset(has_edge,0,sizeof(has_edge));
    memset(d,-1,sizeof(d));
    memset(p,0,sizeof(p));
    int a,count=0;
    int a1,a2,dir1,turn1;
    while(cin>>a)
    {
      if(a==0) break;
      count++;
      if(count==1)
      {
        r0=a;
        cin>>c0>>s>>r2>>c2;
        for(int i=0;i<4;i++)
        {
          if(s[0]==dirs[i])
          {
            dir=i;
            break;
          }
        }
        r1=r0+dr[dir];
        c1=c0+dc[dir];
      }
      else
      {
        a1=a;
        cin>>a2;
        while(cin>>s)
        {
          if(s[0]=='*') break;
          for(int i=0;i<4;i++)
          {
            if(s[0]==dirs[i])
            {
              dir1=i;
              break;
            }
          }
          for(int i=1;i<s.size();i++)
          {
            for(int j=0;j<3;j++)
            {
              if(s[i]==turns[j])
              {
                turn1=j;
                break;
              }
            }
            has_edge[a1][a2][dir1][turn1]=1;
          }
        }
      }
    }
//		for(int i=1;i<=9;i++)
//		{
//			for(int j=1;j<=9;j++)
//			{
//				for(int k=0;k<4;k++)
//				{
//					for(int l=0;l<3;l++)
//					{
//						if(has_edge[i][j][k][l])
//							printf("[%d][%d][%d][%d]\n",i,j,k,l);
//					}
//				}
//			}
//		}
    solve();
  }
  return 0;
}

//图的拓扑排序DAG（有向图的节点排序问题）排序失败说明不是DAG

//有向图的拓扑排序

//WA..有一个陷阱就是n!=0 &&m==0 的情况

#include<stdio.h>

#include<string.h>

#define MAX 100

int c[MAX];

int topo[MAX],t;

int n,m;

int g[MAX][MAX];

bool dfs(int u)

{

   c[u]=-1;

   for(int v=0;v<n;v++)

       if(g[u][v])

       {

           if(c[v]<0)return false;

           else if(!c[v] && !dfs(v))returnfalse;

       }

   c[u]=1;

   topo[--t]=u;

   return true;

}

bool toposort()

{

   t=n;

   memset(c,0,sizeof(c));

   for(int u=0;u<n;u++)

       if(!c[u] && !dfs(u))returnfalse;

   return true;

}

int main()

{

   int i,j;

   while(scanf("%d%d",&n,&m),n)

   {

       memset(g,0,sizeof(g));

       while(m--)

       {

           scanf("%d%d",&i,&j);

           i--;

           j--;

           g[i][j]=1;

       }

       toposort();

       for(i=0;i<n;i++)

       {

           if(i!=0)printf(" ");

           printf("%d",topo[i]+1);

       }

       printf("\n");

   }

   return 0;

}

//图的欧拉回路

#include<stdio.h>
#include<string.h>
int indgr[30],outdgr[30],p[30];
char b[1010];
int find(int x)
{
    return p[x]==x?x:(p[x]=find(p[x]));
}
int main()
{
    int i,j,first,last,t,n,num,ok;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        memset(indgr,0,sizeof(indgr));
        memset(outdgr,0,sizeof(outdgr));
        for(i=0;i<26;i++)
            p[i]=i;
        for(i=0;i<n;i++)
        {
            scanf("%s",b);
            first=b[0]-'a';
            last=b[strlen(b)-1]-'a';
            outdgr[first]++;
            indgr[last]++;
            if(find(first)!=find(last))
                p[find(first)]=find(last);
        }
        num=0;
        ok=1;
        for(i=0;!indgr[i]&&!outdgr[i];i++);
        for(j=i+1;j<26;j++)
            if((indgr[j]||outdgr[j])&&find(i)!=find(j))
                {
                    ok=0;
                    break;
                }
        if(ok)
            for(i=0;i<26;i++)
            {
                if(indgr[i]>outdgr[i])
                {
                    if(indgr[i]-outdgr[i]>1)
                    {
                        ok=0;
                        break;
                    }
                    else
                        num++;
                }
                else if(outdgr[i]>indgr[i])
                {
                    if(outdgr[i]-indgr[i]>1)
                    {
                        ok=0;
                        break;
                    }
                    else
                        num++;
                }
            }
        if(!ok||num>2)
            printf("The door cannot be opened.\n");
        else
            printf("Ordering is possible.\n");
    }
    return 0;
}

2016cxg
关注
DFS和BFS的C++实现
11-30
`dfs`和`bfs`函数分别接受这个图、起始节点和访问状态数组作为参数。 通过以上代码，初学者可以了解DFS和BFS的基本实现方式。在实际应用中，可能需要根据具体问题对这些基础实现进行调整，例如添加额外的数据结构来...
acm算法之vector存图加dfs
qq_52511089的博客
10-03 160
//vector存图+dfs //F - Takahashi Tour AtCoder - abc213_d #include<cstdio> #include<cstring> #include<iostream> #include<math.h> #include<algorithm> #include<vector> using namespace std; const int N=5e5+5; vector<int&.
拓扑排序模板（Kahn算法和DFS实现）
baodream的博客
05-18 1820
拓扑排序思想：每次取出入度为0的顶点删掉，并删掉和该点有关的边，需要维护一个入度为0的队列或者栈模板：int n,m; int inDeg[N]; //i点的入度 vector&lt;int&gt;vec[N]; //i点的邻接表,即i与哪些点相连 int ans[N]; //排序结果数组 int topSort() //返回值代表是否有环,排序结果在ans数组 { in...
基于BFS的最短路径搜索[C++]
FQT_CJ的博客
07-21 1076
基于C++实现BFS的最短路径搜索时，可以使用STL中的优先队列priority_queue，优先队列按照小顶堆，即路径短的优先取出。其中，起点为左上角，终点为右下角，障碍物通过值设置为9999，可以根据题目的要求设置为一个非常大的值。...
关于使用Vector容器建图以及BFS、DFS遍历
misgod的博客
10-24 1128
关于使用Vector容器建图以及BFS、DFS遍历： Vector建图是真的简单…多的不谈，直接上代码！ // // main.cpp // Created on 2020/10/24. // #include <iostream> #include <queue> #include <vector> using namespace std; const int Max_Len = 100 ;//最多100个节点 int Visited[Max_Len] ;//标记
DFS递归+递归函数模板+vector的注意事项
Sti1lWater的博客
03-14 209
DFS vector
bfs-dfs.rar_BFS algoritm_BFS+c++
09-22
BFS和DFS是图论和算法领域中非常基础且重要的搜索策略，广泛应用于解决各种问题，例如在社交网络中查找最近公共祖先、在迷宫中寻找出路等。通过理解这两种算法，可以提高解决问题的能力并为学习更复杂的算法打下基础...
06B 临接矩阵1
08-03
其中，状态`VStatus`有三种：未发现(UNDISCOVERD)、已发现(DISCOVERD)和已访问(VISITED)，这通常用于图遍历算法如深度优先搜索(DFS)或广度优先搜索(BFS)。 `Edge`结构体表示图中的边，包含边的数据、权重以及边的...
图的邻接矩阵和邻接表表示
06-10
在实现过程中，需要考虑图的遍历（深度优先搜索DFS和广度优先搜索BFS）、添加边、删除边以及查找路径等操作。 **4. 功能与运行界面** 描述中提到的实现可能包含了完整的功能，如读取图的输入、输出结果、显示图形...
C++使用DFS（深度优先）遍历邻接矩阵（源代码）
最新发布
05-30
图的遍历是图论中的一个重要概念，主要涉及两种基本方法：深度优先搜索（DFS）和广度优先搜索（BFS）。 1. **深度优先搜索（DFS）**：从某个顶点开始，尽可能深地搜索图的分支。当节点v的所在边都已被探寻过，搜索...
c++, DFS遍历模板类, 可避免写递归逻辑
07-18
c++, DFS遍历模板类, 可避免写递归逻辑, 具体例子可以参考.h中的namespace
小字辈
weixin_43723935的博客
10-02 276
本题给定一个庞大家族的家谱，要请你给出最小一辈的名单。 输入格式： 输入在第一行给出家族人口总数 N（不超过 100 000 的正整数） —— 简单起见，我们把家族成员从 1 到 N 编号。随后第二行给出 N 个编号，其中第 i 个编号对应第 i 位成员的父/母。家谱中辈分最高的老祖宗对应的父/母编号为 -1。一行中的数字间以空格分隔。 输出格式： 首先输出最小的辈分（老祖宗的辈分为 1，以下逐级递增）。然后在第二行按递增顺序输出辈分最小的成员的编号。编号间以一个空格分隔，行首尾不得有多余空格。
图论dfs（vector储存）
郭源潮
09-15 401
D. Cow and Snacks time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output The legendary Farmer John is throwing a huge party, and animal...
vector邻接表建图+DFS+BFS
hambaga的博客
12-27 954
以边操作为主的图用边集数组存储比较好，相比链式前向星，vector建图更容易懂。 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;cstdio&amp;amp;gt; #include &amp;amp;lt;cstring&amp;amp;gt; #include &amp;amp;lt;vector&amp;amp;gt; #include &a
NYoj 20 深搜
hunxiejun
09-13 234
是一道无根树转化为有根树的题目，暑假时迷迷糊糊的ac了，其实并没有理解其实质，，今天又重新做了一遍，才知道原来无根树转化为有根树实质就是一个深搜的过程，，把一条路径上的点都找出即可。。。题目： 在一个吝啬的国度里有N个城市，这N个城市间只有N-1条路把这个N个城市连接起来。现在，Tom在第S号城市，他有张该国地图，他想知道如果自己要去参观第T号城市，必须经过的前一个城市是几号...
vector,list实现图的邻接表 DFS遍历
Abudula__的博客
06-11 928
图的实现 图的实现有两种方法，一种是邻接矩阵，另一种是邻接表，这两种实现各有各的优缺点，以下给出了邻接表的实现并且DFS遍历的代码实现。 举例 // A simple representation of graph using STL #include<iostream> #include<vector> #include<list> using namesp...
数据结构__广度优先遍历（BFS）用STL的vector与queue实现
My Struggle
01-19 839
给出代码： #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;queue&gt; #define maxn 1000 bool inq[maxn] = { false }; using namespace std; struct node { int adjvex; char data; int weight; i...
c++PTA A1094(vector+dfs)
执念斩长河
01-27 146
这道题用vector存储孩子节点数量，只要孩子结点一直有那就不断地DFS，最后遍历输出就行。
uva 11292
NITjianbagengmu的博客
05-06 362
水题#include<iostream> #include<string> #include<set> #include<queue> #include<vector> #include<map> #include<algorithm> #include<cstdio> #include<cstring> #include<cstdlib> #include<
dfs和bfs算法实现c++
09-07
DFS（深度优先搜索）和BFS（广度优先搜索）算法是图论中常见的两种算法，用于遍历图或树的节点。以下是C++实现： DFS算法实现： ```c++ #include #include <vector> #include using namespace std; void dfs...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值