Question

我写了一个代码，首先将矩阵的维（n X m）作为输入，然后是0 s和1 s的元素。现在我正在尝试使用该矩阵构建图形（邻接列表表示），使得所有1 s连接到它们相邻的所有其他1（即，垂直，水平或对角）。矩阵元素以行主要方式编号，以便将它们表示为图形的顶点。

以下是代码：

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <list>
#include <deque>

using namespace std;

class Graph
{
 public:

    list<int> *adjlist;
    int v;

    Graph(int v)
    {
        this->v=v;
        adjlist=new list<int> [v];      
    }

    void add_edge(int src, int dest)
    {
        cout<<src<<" "<<dest<<"\n";
        adjlist[src].push_back(dest);
    }

    void dfs_util(int src, bool *visited)
    {
        if(!visited[src])
        {
            cout<<src<<" ";
            visited[src]=true;
            list<int>::iterator i;
            for(i=adjlist[src].begin(); i!=adjlist[src].end(); i++)
            {
                if(!visited[*i])
                {
                    dfs_util(*i, visited);
                }
            }
        }
    }

    void dfs(int src)
    {
        bool visited[v];
        int i;
        for(i=0; i<v; i++)
            visited[i]=false;
        dfs_util(src, visited);
    }

    void bfs(int src)
    {
        int j;
        bool visited[v];
        for(j=0; j<v; j++)
        {
            visited[j]=false;
        }

        int front;
        deque<int> q;
        q.push_back(src);
        list<int>::iterator i;
        visited[src]=true;


        while(!q.empty())
        {
            front=q.front();
            q.pop_front();
            cout<<front<<" ";

            for(i=adjlist[front].begin(); i!=adjlist[front].end(); i++)
            {
                cout<<*i<<"\n";
                if(!visited[*i])
                {
                    visited[*i]=true;
                    q.push_back((*i));
                }
            }
        }
    }

    void display()
    {
        list<int>::iterator it;
        int i;
        //list<int>::iterator it;

        for(i=0; i<v; i++)
        {           
            cout<<"Adj list for "<<i<<"\n";
            for(it=adjlist[i].begin(); it != adjlist[i].end(); ++it)
            {
                cout<<*it<<"->";
            }
            cout<<"\n";
        }
    }
};


int main() {
    int arr[11][11], n, m, i, j, node;
    cin>>n;
    cin>>m;

    for(i=0; i<n; i++)
    {
        for(j=0; j<m; j++)
        {
            cin>>arr[i][j];
        }
    }

    Graph g(n*m-1);

    for(i=0; i<n; i++)
    {
        for(j=0; j<m; j++)
        {
            node=m*i+j;
            if(arr[i][j]==1)
            {
                if((i-1)>=0 && arr[i-1][j]==1)
                    g.add_edge(node, m*(i-1)+j);

                if((i-1)>=0 && (j+1)<m && arr[i-1][j+1]==1)
                    g.add_edge(node, m*(i-1)+(j+1));

                if((j+1)<m && arr[i][j+1]==1)
                    g.add_edge(node, m*(i)+(j+1));

                if((i+1)<n && (j+1)<m && arr[i+1][j+1]==1)
                    g.add_edge(node, m*(i+1)+(j+1));

                if((i+1)<n && arr[i+1][j]==1)
                    g.add_edge(node, m*(i+1)+(j));

                if((i+1)<n && (j-1)>=0 && arr[i+1][j-1]==1)
                    g.add_edge(node, m*(i+1)+(j-1));

                if((j-1)>=0 && arr[i][j-1]==1)
                    g.add_edge(node, m*(i)+(j-1));

                if((i-1)>=0 && (j-1)>=0 && arr[i-1][j-1]==1)
                    g.add_edge(node, m*(i-1)+(j-1));
            }
        }       
    }

    //g.bfs(0);
    //g.dfs(0);
    g.display();
    return 0;
}

现在，此代码在调用segmentation fault或g.bfs(0)时给了我g.dfs(0)。所以我写了一个简单的显示函数来缩小错误，但即使调用g.display()也会给我segmentation fault。

但是当我将display()函数中的外部循环更改为：

时

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

它完全正常，并没有给出segmentation fault。

我无法理解为什么我会得到这些segmentation fault以及如何将外循环的初始化更改为1来阻止它。有人可以解释原因吗？

以下是我使用的示例输入：

Answer 1

<强>问题

您的邻接列表是一个数组，而不是列表或向量：

list<int> *adjlist;

您可以在参数v：

的基础上在构造函数中初始化它

adjlist=new list<int> [v];

因此，在构建图表时，您需要提前提供多少邻接列表？所以最好不要犯错误！

不幸的是，在main()中，您使用缺少的项目初始化

Graph g(n*m - 1);   //  <----- why -1 ?  Don't you have n*m nodes ?

<强>解决方案

只需使用正确的大小调用构造函数

Graph g(n*m);   //  n*m nodes !

通过添加一些绑定检查，你可以帮助自己解决这个问题：

void add_edge(int src, int dest)   // src should be smaller than v 
{
    if (src>=v) {         // nice diagnostic message in case of problem
       cout <<"FAILURE: "<<src<<" out of bound ("<<v<<")"<<endl; 
    }
    else {
        cout<<src<<" "<<dest<<"\n";
        adjlist[src].push_back(dest);
    }
}

如果不总是实现这样的错误消息，它应该成为至少assert满足前提条件的反射：

assert (src<v && dest<v);

最好是将邻接列表adjlist设为矢量或地图，然后让它动态增长。

特定值的分段错误

1 个答案: