C++ 生成具有n个节点的所有无向图

我尝试使用递归回溯生成所有具有n个节点的无向图。我必须将他们的矩阵（我不知道它在英语中是如何命名的——在我的语言中，它将是相邻的矩阵——是这样吗？）写入一个文件

例如：

输入

输出

8
0 0 0 
0 0 0 
0 0 0 

0 0 0 
0 0 1 
0 1 0 

0 0 1 
0 0 0 
1 0 0 

0 0 1 
0 0 1 
1 1 0 

0 1 0 
1 0 0 
0 0 0 

0 1 0 
1 0 1 
0 1 0 

0 1 1 
1 0 0 
1 0 0 

0 1 1 
1 0 1 
1 1 0 

这是我的节目：

#include <iostream>
#include <fstream>

using namespace std;

ifstream f("gengraf.in");
ofstream g("gengraf.out");

int st[100], n, adiacenta[100][100], l=1;

void tipar(int k)
{
    for (int i = 1; i < k; i++)
    {
        for (int j = i+1; j < k; j++)
        {
            adiacenta[i][j] = adiacenta[j][i] = st[l];
        }
        l++;
    }
    for (int i = 1; i < k; i++)
    {
        for (int j = 1; j < k; j++)
        {
            g << adiacenta[i][j] << " ";
        }
        g << endl;
    }
}

int valid(int k)
{
    return 1;
}

void back(int k)
{
    if (k == ((n - 1) * n / 2) + 1)
    {
        l = 1;
        tipar(k);
        g << endl;
    }
    else
    {
        for (int i = 0; i <= 1; i++)
        {
            st[k] = i;
            if (valid(k))
            {
                back(k + 1);
            }
        }
    }
}

int main()
{
    f >> n;
    g << pow(2, (n * (n - 1))/2);
    g << endl;
    back(1);
}

我不知道如何解决这个问题

我明白了为什么会发生这种情况——我生成了2^（n*（n-1））/2个图（因为这就是有n个节点的无向图的数量），而不是生成8个不同的图，我只得到了4个不同的图，显示了2次

这是（我想）因为我的程序输出一个带有节点1和3之间链接的图，以及另一个带有节点3和1之间链接的图。这基本上是相同的无向图

因此，如果我是对的，我应该让我的程序不显示每个图形两次，它应该工作。所以基本上我必须去掉每个有“反向”节点的图（所以如果我得到一个链接在1和3之间的图，我不应该得到另一个链接在3和1之间的图，因为它们是相同的）

我说得对吗

如果是，我该怎么做

---

谢谢。

您的代码有问题：

• tipar（）

  id中的

  l

  值在赋值后不会增加
• 邻接矩阵的大小是n*n而不是k*k

此代码按预期工作

#include <iostream>
#include <fstream>

using namespace std;

ifstream f("gengraf.in");
ofstream g("gengraf.out");

int st[100], n, adiacenta[100][100], l=1;

int pow(int a, int b) {
    int r = 1;
    while (b) {
    if (b&1) r *= a;
    b >>= 1;
    a *= a;
    }
    return r;
}

void tipar()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = i+1; j <= n; j++)
        {
            adiacenta[i][j] = adiacenta[j][i] = st[l];
            l++;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            g << adiacenta[i][j] << " ";
        }
        g << endl;
    }
}

int valid(int k)
{
    return 1;
}

void back(int k)
{
    if (k == (n * (n-1) / 2) + 1)
    {
        l = 1;
        tipar();
        g << endl;
    }
    else
    {
        for (int i = 0; i <= 1; i++)
        {
            st[k] = i;
            if (valid(k))
            {
                back(k+1);
            }
        }
    }
}

int main()
{
    cin >> n;
    g << pow(2, (n * (n - 1))/2);
    g << endl;
    back(1);
}

#包括
#包括
使用名称空间std；
IFF流（“gengraf.in”）；
流g（“gengraf.out”）；
int st[100]，n，adiacenta[100][100]，l=1；
内部功率（内部a、内部b）{
int r=1；
而(二){
如果（b&1）r*=a；
b>>=1；
a*=a；
}
返回r；
}
void tipar（）
{
对于代码中的（inti=1；i问题：


tipar（）
id中的
l
值在赋值后不会增加
邻接矩阵的大小是n*n而不是k*k

此代码按预期工作

#include <iostream>
#include <fstream>

using namespace std;

ifstream f("gengraf.in");
ofstream g("gengraf.out");

int st[100], n, adiacenta[100][100], l=1;

int pow(int a, int b) {
    int r = 1;
    while (b) {
    if (b&1) r *= a;
    b >>= 1;
    a *= a;
    }
    return r;
}

void tipar()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = i+1; j <= n; j++)
        {
            adiacenta[i][j] = adiacenta[j][i] = st[l];
            l++;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            g << adiacenta[i][j] << " ";
        }
        g << endl;
    }
}

int valid(int k)
{
    return 1;
}

void back(int k)
{
    if (k == (n * (n-1) / 2) + 1)
    {
        l = 1;
        tipar();
        g << endl;
    }
    else
    {
        for (int i = 0; i <= 1; i++)
        {
            st[k] = i;
            if (valid(k))
            {
                back(k+1);
            }
        }
    }
}

int main()
{
    cin >> n;
    g << pow(2, (n * (n - 1))/2);
    g << endl;
    back(1);
}

#包括
#包括
使用名称空间std；
IFF流（“gengraf.in”）；
流g（“gengraf.out”）；
int st[100]，n，adiacenta[100][100]，l=1；
内部功率（内部a、内部b）{
int r=1；
而(二){
如果（b&1）r*=a；
b>>=1；
a*=a；
}
返回r；
}
void tipar（）
{
对于（int i=1；i）方法“valid”总是输出1。有理由这样做吗？因为这样你就不需要带有
back（k+1）的
if（）
语句；
在其中，因为walid的结果总是1=true；这是我从我的一位老师那里学到的一个模板链接。在valid（）函数，我应该有必须满足的条件才能使解决方案正常。在这种情况下，所有节点的变化都很好，所以它总是返回1。这就像一个模板*它应该有条件*抱歉，输入错误，stackoverflow不允许我编辑它，尽管方法“有效”总是输出1。有理由这样做吗？因为这样你就不需要带
back（k+1）的
if（）
语句；
，因为walid的结果总是1=true；这是我从我的一位老师那里学到的一个模板函数，我应该有必须满足的条件，以使解决方案是好的。在这种情况下，所有节点的变化都是好的，所以它总是返回1。这就像一个模板*它应该有条件*抱歉，打字错误，stackoverflow不会让我编辑它，谢谢。我不得不将cin更改为f，但实际上它是w按预期工作。回答得很好！非常感谢。我不得不将cin更改为f，但它确实按预期工作。回答得很好！
#include <iostream>
#include <fstream>

using namespace std;

ifstream f("gengraf.in");
ofstream g("gengraf.out");

int st[100], n, adiacenta[100][100], l=1;

int pow(int a, int b) {
    int r = 1;
    while (b) {
    if (b&1) r *= a;
    b >>= 1;
    a *= a;
    }
    return r;
}

void tipar()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = i+1; j <= n; j++)
        {
            adiacenta[i][j] = adiacenta[j][i] = st[l];
            l++;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            g << adiacenta[i][j] << " ";
        }
        g << endl;
    }
}

int valid(int k)
{
    return 1;
}

void back(int k)
{
    if (k == (n * (n-1) / 2) + 1)
    {
        l = 1;
        tipar();
        g << endl;
    }
    else
    {
        for (int i = 0; i <= 1; i++)
        {
            st[k] = i;
            if (valid(k))
            {
                back(k+1);
            }
        }
    }
}

int main()
{
    cin >> n;
    g << pow(2, (n * (n - 1))/2);
    g << endl;
    back(1);
}