BZOJ1002: [FJOI2007]轮状病毒

1002: [FJOI2007]轮状病毒

Time Limit: 1 Sec Memory Limit: 162 MB

Description

　　轮状病毒有很多变种，所有轮状病毒的变种都是从一个轮状基产生的。一个N轮状基由圆环上N个不同的基原子
和圆心处一个核原子构成的，2个原子之间的边表示这2个原子之间的信息通道。如下图所示

　　N轮状病毒的产生规律是在一个N轮状基中删去若干条边，使得各原子之间有唯一的信息通道，例如共有16个不
同的3轮状病毒，如下图所示

　　现给定n(N<=100)，编程计算有多少个不同的n轮状病毒

Input

　　第一行有1个正整数n

Output

　　计算出的不同的n轮状病毒数输出

Sample Input

Sample Output

这个题的直接题意是给一个无向图G，求它的生成树个数。

设G的度数矩阵为D(G)，大小为n*n，对于D(G)，当i!=j时，Dij=0，当i=j时，Dij=点i的度数。

设G的邻接矩阵为A(G)，大小为n*n，对于A(G)，如果i与j之间有直接相连的边，Aij=1，否则Aij=0。

那么对于图G的基尔霍夫矩阵C(G)=D(G)-A(G)

Matrix-Tree定理:G的所有不同的生成树的个数等于其基尔霍夫矩阵C[G]任何一个n-1阶主子式的行列式的绝对值；
所谓n-1阶主子式,就是对于r(1≤r≤n),将C[G]的第r行,第r列同时去掉后得到的新矩阵,用Cr[G]表示;

这个时候就可以n^3暴力求解基尔霍夫矩阵

或者用一种我暂时不知道的方法推出f[i]=3*f[i-1]-f[i-2]+2，

或者也可以DP，对于只是一条链的情况，设f[i][0]为第i个点与源点还未相连，并且前i-1个点和中心点或者第i个点是连通的，f[i][1]为前i个点都与源点连通了，那么:

f[i][0]=f[i-1][0]+f[i-1][1]

f[i][1]=f[i-1][0]+f[i-1][1]*2

有了这个以后，我们只需要枚举源点和多少个周围点相连，其他的情况都是一条链。

最后答案ans=∑i*i*f[i][1] (1<=i<=n)

三种方法高精度都是必须的

附上法2的代码

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

const int maxn=200;

struct bign
{
    int len,s[maxn];
    bign()
    {
        memset(s,0,sizeof(s));
        len = 1;
    }
    bign(int num)
    {
        *this = num;
    }
    bign(const char* num)
    {
        *this = num;
    }
    bign operator=(int num)
    {
        char s[maxn];
        sprintf(s,"%d",num);
        *this = s;
        return *this;
    }

  string str() const {
    string res = "";
    for(int i = 0; i < len; i++) res = (char)(s[i] + '0') + res;
    if(res == "") res = "0";
    return res;
  }

  void clean() {
    while(len > 1 && !s[len-1]) len--;
  }



  bign operator = (const char* num) {

    len = strlen(num);
    for(int i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
    return *this;
  }

  bign operator + (const bign& b) const{
    bign c;
    c.len = 0;
    for(int i = 0, g = 0; g || i < max(len, b.len); i++) {
      int x = g;
      if(i < len) x += s[i];
      if(i < b.len) x += b.s[i];
      c.s[c.len++] = x % 10;
      g = x / 10;
    }
    return c;
  }

  bign operator * (const bign& b) {
    bign c; c.len = len + b.len;
    for(int i = 0; i < len; i++)
      for(int j = 0; j < b.len; j++)
        c.s[i+j] += s[i] * b.s[j];
    for(int i = 0; i < c.len-1; i++){
      c.s[i+1] += c.s[i] / 10;
      c.s[i] %= 10;
    }
    c.clean();
    return c;
  }

  bign operator - (const bign& b) {
    bign c; c.len = 0;
    for(int i = 0, g = 0; i < len; i++) {
      int x = s[i] - g;
      if(i < b.len) x -= b.s[i];
      if(x >= 0) g = 0;
      else {
        g = 1;
        x += 10;
      }
      c.s[c.len++] = x;
    }
    c.clean();
    return c;
  }

  bool operator < (const bign& b) const{
    if(len != b.len) return len < b.len;
    for(int i = len-1; i >= 0; i--)
      if(s[i] != b.s[i]) return s[i] < b.s[i];
    return false;
  }

  bool operator > (const bign& b) const{
    return b < *this;
  }

  bool operator <= (const bign& b) {
    return !(b > *this);
  }

  bool operator == (const bign& b) {
    return !(b < *this) && !(*this < b);
  }

  bign operator += (const bign& b) {
    *this = *this + b;
    return *this;
  }
};

istream& operator >> (istream &in, bign& x) {
  string s;
  in >> s;
  x = s.c_str();
  return in;
}

ostream& operator << (ostream &out, const bign& x) {
  out << x.str();
  return out;
}

int main()
{
    bign f[110];
    int n;
    cin >> n;
    f[1]+="1";
    f[2]+="5";
    f[0]+="3";
    for (int i=3 ; i<=n ; i++)
        f[i]=f[0]*f[i-1]-f[i-2]+2;
    cout << f[n] << endl;
    return 0;
}