題目連結

題目描述：
給出n個點，求n個點的無向連通圖

分析：
巨坑啊

經典題目，有兩種方法：

總方案數-不合法方案

n$n$個點的完全圖有C(n,2)=n(n−1)2$C(n,2)=\frac{n(n-1)}{2}$條邊，顯然就有2C(n,2)$2^{C(n,2)}$種子圖（列舉每條邊是否選擇）

設f[i]$f[i]$表示每個點都和點1相連的連通圖的個數
假設1號點所在的連通塊大小為i$i$
那麼和1連通的這i−1$i-1$個點就有C(n−1,i−1)$C(n-1,i-1)$種選擇，方案數為C(n−1,i−1)∗f[i]$C(n-1,i-1)\ast f[i]$

其它n−i$n-i$個點間任意連邊即可，方案數為2C(n−i,2)$2^C$

則有遞推公式：

在程式碼實現上，基本上都是高精度
所以網上的程式碼都是什麼Java，python之類的

直接求方案數

考慮去掉1號點時，2號點的情況
設此時2所在的連通塊共有i$i$個點
這i$i$個點和剩下的n−i$n-i$個點分別處在兩個不同連通塊中（下面就要把這兩個連通塊連線在一起）
其方案數為f[i],f[n−i]$f[i],f[n-i]$，2號點需要在剩下的點（除去點1，點2）中選擇

則有遞推公式

這種思路xue微有點困難，而且還是需要用高精度
不過只需要高精加和高精乘即可（比第一種方法簡單一點）

tip

方法二code

#include<cstdio>
#include<iostream>
#include<cstring>
#define ll long long

using namespace std;

int n,nn=2;
struct node{
    int o[400],len;

    node operator *(const node &a) const {
        int L=(len+a.len);
        node ans; ans.clear();
        ans.len=L;
        for (int i=1;i<=len;i++)
            for (int j=1;j<=a.len;j++) {
                ans.o[i+j-1]+=o[i]*a.o[j];
                ans.o[i+j]+=ans.o[i+j-1]/10;
                ans.o[i+j-1]%=10;
            }
        while (!ans.o[ans.len]) ans.len--;
        return ans;
    }

    node operator +(const node &a) const {
        int L=max(len,a.len);
        int d=0;
        node ans; ans.clear();
        for (int i=1;i<=L;i++) {
            ans.o[i]=o[i]+a.o[i]+d;
            d=ans.o[i]/10;
            ans.o[i]%=10;
        }
        ans.len=L;
        if (d) ans.o[++ans.len]=d;
        return ans;    
    }

    void clear() {memset(o,0,sizeof(o));len=0;}

    node get(ll x) {
        node ans; ans.clear();
        while (x) {
            ans.o[++ans.len]=x%10;
            x/=10;
        }
        return ans;
    }
};
node f[51],c[51][51];

void prepare() {
    c[0][0].len=1; c[0][0].o[1]=1;
    for (int i=1;i<=50;i++) {
        c[i][0].o[1]=1; c[i][0].len=1;
        for (int j=1;j<=i;j++) 
            c[i][j]=c[i-1][j]+c[i-1][j-1]; 
    }
}

void solve(int n) {
    node t; 
    for (int i=1;i<n;i++) {
        t=t.get((1LL<<i)-1); 
        f[n]=f[n]+f[i]*f[n-i]*c[n-2][i-1]*t;
    }
}

void print(int n) {
    for (int i=f[n].len;i>=1;i--)
        printf("%d",f[n].o[i]);
    printf("\n");
}

int main()
{
    f[1].o[1]=1; f[1].len=1;
    f[2].o[1]=1; f[2].len=1;
    nn=2;
    prepare();
    while (scanf("%d",&n)!=EOF&&n) {
        if (n<=nn) {print(n);continue;}
        for (int i=nn+1;i<=n;i++) 
            solve(i);
        nn=n;
        print(n);
    }
    return 0;
}