ZOJ Monthly, February 2008 总结

9 Comments2008.02.24 23:44　by Felicia　

这次比赛 GCC 只能说是发挥得一般。一共出了5个题，排名第9。感觉上还 1007 应该能出的。如果做出6题，排名能到第4，那就很好了。

这次比赛有两个题目比较好：1007 和 1009。1007 没能 AC。1009 经过我和 mmd 的讨论，最后 AC 了。
[Read more]

[图论] pku3417 树上的统计

1 Comment2007.10.06 20:53　by Felicia　

我的做法是，对于每条新边，记录树中与之对应的路径。然后对于每条树边，统计被对应的次数。最后记录每个点到树根的路径上，有多少个1（设为q[i]）。对于新边(x,y)，它对答案的贡献就是q[x] + q[y] – 2q[lca(x,y)]。除了这些，答案还应加上树中0边的数量 * m。

下面是我的代码

下载: pku3417.cpp
/**********************************************************************
Author: WHU_GCC
Created Time: 2007-10-6 12:45:53
File Name: pku3417.cpp
Description:
**********************************************************************/
#include <iostream>
#include <cmath>
using namespace std;
#define out(x) (cout<<#x<<": "<<x<<endl)
const int maxint=0x7FFFFFFF;
 
const int maxn = 100010;
 
struct node_t
{
    int father;
    int value;
    int pre;
};
 
struct tmp_t
{
    int v;
    tmp_t *next;
};
 
int n, m;
node_t p[maxn];
tmp_t *u[maxn];
int edge_u[maxn];
int edge_v[maxn];
int edge_lca[maxn];
int *d[20][200010];
int euler[maxn * 2];
int a[maxn * 2];
int high[maxn];
int stt[maxn];
int tim;
int *mmin(int *a, int *b)
{
    if (*a < *b)
        return a;
    return b;
}
void make_rmq(int n)
{
    int i, j;
    for (i = 1; i <= n; i++)
         d[0][i] = &a[i];
    for (j = 1; j <= log((double)n) / log (2.0);j++)
        for (i = 1; i + (1 << j) - 1 <= n; i++)
            d[j][i] = mmin (d[j - 1][i], d[j - 1][i + (1 << (j - 1))]);
}
int *rmq(int i,int j)
{
    if (i > j)
        swap (i, j);
    int k = (int)(log (j - i + 1.) / log (2.0));
    return mmin (d[k][i], d[k][j - (1 << k) + 1]);
}
void mmd (int f, int v, int h)
{
    euler[++tim] = v;
    high[v] = h;
    tmp_t *pt;
    for (pt = u[v]; pt; pt = pt->next)
        if (pt->v != f)
        {
            mmd (v, pt->v, h + 1);
            euler[++tim] = v;
        }
}
 
void build ()
{
    tim = 0;
    mmd (1, 1, 1);
    memset (stt, 0, sizeof (stt));
    int i;
    for (i = 1; i <= tim; ++i)
    {
        if (stt[euler[i]] == 0)
            stt[euler[i]] = i;
        a[i] = high[euler[i]];
    }
    make_rmq (tim);
}
int lca (int u, int v)
{
    return euler[rmq (stt[u], stt[v]) - a];
}
 
int f[maxn];
int g[maxn];
int q[maxn];
 
int dfs(int father, int now)
{
    int ret = 0;
    tmp_t *t;
    for (t = u[now]; t; t = t->next)
        if (t->v != father)
            ret += dfs(now, t->v);
    return g[now] = ret + f[now];
}
 
void dfs1(int father, int now, int sum)
{
    q[now] = sum + (g[now] == 1);
    tmp_t *t;
    for (t = u[now]; t; t = t->next)
        if (t->v != father)
            dfs1(now, t->v, sum + (g[now] == 1));
}
 
int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        memset(u, 0, sizeof(u));
        int i;
        for (i = 0; i < n - 1; i++)
        {
            int t1, t2;
            scanf("%d%d", &t1, &t2);
            tmp_t *p = new tmp_t;
            p->v = t2;
            p->next = u[t1];
            u[t1] = p;
            
            p = new tmp_t;
            p->v = t1;
            p->next = u[t2];
            u[t2] = p;
        }
        memset(p, 0, sizeof(p));
        for (i = 1; i <= n; i++)
            p[i].pre = i;
        build();
        memset(f, 0, sizeof(f));
        for (i = 0; i < m; i++)
        {
            int t1, t2;
            scanf("%d%d", &t1, &t2);
            edge_u[i] = t1;
            edge_v[i] = t2;
            int t = lca(t1, t2);
            edge_lca[i] = t;
            f[t1]++;
            f[t2]++;
            f[t] -= 2;
        }
        memset(g, 0, sizeof(g));
        dfs(1, 1);
        memset(q, 0, sizeof(q));
        dfs1(1, 1, 0);
        int sum = 0;
        for (i = 2; i <= n; i++)
            if (g[i] == 0)
                sum++;
        int ans = 0;
        for (i = 0; i < m; i++)
            ans += q[edge_u[i]] + q[edge_v[i]] - 2 * q[edge_lca[i]];
        printf("%d\n", ans + sum * m);
    }
    return 0;
}

[转载][图论] 给出一个没有偶圈的简单无向图，求两个顶点间路径的数目

Leave a Comment2007.09.19 10:08　by Felicia　

给出一个没有偶圈的简单无向图，求两个顶点间路径的数目。习题：WOJ 1156

老实说，这个题目其实不容易，在正式竞赛中肯定不属于送分题。题目的难点在于发现”没有偶圈”这个条件反映的图的特殊性质。

如提示中所说，考虑图的双连通分量。首先解释一下什么是双连通分量。无向图中某个顶点如果被删除之后，连通分量的数目增加，那么这个顶点就叫做割点。无向图中不包含割点的极大子图就是双连通分量。

双连通分量中任意两顶点共圈。从这个性质出发，可以证明：没有偶圈的简单无向图的所有双连通分量只能是2阶完全图或奇圈，收缩所有双连通分量之后得到的图是树。这两个性质意味着，图中两个顶点间的路径经过的双连通分量的序列是相同的。由此得到以下算法：

  1. 求出图的所有双连通分量；
  2. 确定从顶点u到顶点v的一条路径；
  3. 确定路径经过的双连通分量的序列；
  4. 确定序列中是奇圈的双连通分量的数目，记为k，则路径数为2k。

在分析上述算法的复杂度之间，先补充一下图的另一个性质。因为图中没有偶圈，所以图中不包含同胚于5阶完全图或3,3完全二部图的子图，根据Kuratowski定理，这个图是平面图，由此可得m = O(n)。

现在来分析算法的复杂度。第1步可以利用J. Hopcroft提出的线性时间算法在O(n + m) = O(n)时间内完成。第2步可以用宽度优先搜索在O(n)时间内实现。第3步可以直接在O(n)时间内实现。第4步是整个算法的瓶颈。 它需要计算一个O(2n/2)的数值。使用一般的算法实现时间复杂度将为O(n2)，如果使用快速正交变换实现时间复杂度将为O(nlogn)。综合以上四个结果，算法的时间复杂度是O(nlogn)。算法的空间复杂度为O(n)。

[图论] pku1125 所有顶点对的最短路

Leave a Comment2007.09.02 20:09　by Felicia　

简单题。很早以前做的。

下面是我的代码

下载: pku1125.cpp
#include <cstdio>
#include <cstring>
int n,i,j,k,tmp,best,nbest,t1,t2;
int a[110][110],num[110];
bool flag;
int main() {
    while (scanf("%d",&n),n) {
        memset(a,0x7f,sizeof(a));
        for (i=1;i<=n;i++) {
            scanf("%d",&num[i]);
            for (j=1;j<=num[i];j++) {
                scanf("%d%d",&t1,&t2);
                a[i][t1]=t2;
            }
        }
        for (i=1;i<=n;i++) a[i][i]=0;
        for (k=1;k<=n;k++)
            for (i=1;i<=n;i++)
                for (j=1;j<=n;j++)
                    if (a[i][k]!=0x7f7f7f7f && a[k][j]!=0x7f7f7f7f) a[i][j]<?=a[i][k]+a[k][j];
        for (best=0x7fffffff,i=1;i<=n;i++) {
            flag=false;
            for (tmp=0,j=1;j<=n;j++) {
                tmp>?=a[i][j];
                if (a[i][j]==0x7f7f7f7f) {
                    flag=true;
                    break;
                }
            }
            if (!flag) {
                if (tmp<best) {
                    best=tmp;
                    nbest=i;
                }
            }
        }
        if (best==0x7fffffff) printf("disjoint\n");
        else printf("%d %d\n",nbest,best);
    }
    return 0;
}

[动态规划][图论] pku1737 一维递推

Leave a Comment2007.09.02 13:53　by Felicia　

楼爷的题。递推。f[n]表示n个结点的连通图个数，则有递推公式：

f[n] = 0;
for (int i = 1; i < n; i++)
f[n] += f[i] * f[n - i] * (pow(i) – 1) * C(n – 2, i – 1);
pow(x) == 2^x

因为数据较多，所以预先算出f[1] — f[50]，再输出。要用高精度。我用了标程。

下面是我的代码

下载: pku1737.cpp
/**********************************************************************
Author: WHU_GCC
Created Time: 2007-9-2 10:02:30
File Name: pku1737.cpp
Description:
**********************************************************************/
#include <iostream>
using namespace std;
#define out(x) (cout << #x << ": " << x << endl)
const int maxint = 0x7FFFFFFF;
typedef long long int64;
const int64 maxint64 = 0x7FFFFFFFFFFFFFFFLL;
template <class T> void show(T a, int n) {for (int i = 0; i < n; ++i) cout << a[i] << ' '; cout << endl; }
template <class T> void show(T a, int r, int l) {for (int i = 0; i < r; ++i) show(a[i], l); cout << endl; }
 
#define DIGIT 4
#define DEPTH 10000
#define MAX 2000
typedef int bignum_t[MAX+1];
 
int read(bignum_t a,istream& is=cin){
    char buf[MAX*DIGIT+1],ch;
    int i,j;
    memset((void*)a,0,sizeof(bignum_t));
    if (!(is>>buf)) return 0;
    for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
        ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch;
    for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
    for (i=1;i<=a[0];i++)
        for (a[i]=0,j=0;j<DIGIT;j++)
            a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0';
    for (;!a[a[0]]&&a[0]>1;a[0]--);
    return 1;
}
 
void write(const bignum_t a,ostream& os=cout){
    int i,j;
    for (os<<a[i=a[0]],i--;i;i--)
        for (j=DEPTH/10;j;j/=10)
            os<<a[i]/j%10;
}
 
int comp(const bignum_t a,const bignum_t b){
    int i;
    if (a[0]!=b[0])
        return a[0]-b[0];
    for (i=a[0];i;i--)
        if (a[i]!=b[i])
            return a[i]-b[i];
    return 0;
}
 
int comp(const bignum_t a,const int b){
    int c[12]={1};
    for (c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);
    return comp(a,c);
}
 
int comp(const bignum_t a,const int c,const int d,const bignum_t b){
    int i,t=0,O=-DEPTH*2;
    if (b[0]-a[0]<d&&c)
        return 1;
    for (i=b[0];i>d;i--){
        t=t*DEPTH+a[i-d]*c-b[i];
        if (t>0) return 1;
        if (t<O) return 0;
    }
    for (i=d;i;i--){
        t=t*DEPTH-b[i];
        if (t>0) return 1;
        if (t<O) return 0;
    }
    return t>0;
}
 
void add(bignum_t a,const bignum_t b){
    int i;
    for (i=1;i<=b[0];i++)
        if ((a[i]+=b[i])>=DEPTH)
            a[i]-=DEPTH,a[i+1]++;
    if (b[0]>=a[0])
        a[0]=b[0];
    else
        for (;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);
    a[0]+=(a[a[0]+1]>0);
}
 
void add(bignum_t a,const int b){
    int i=1;
    for (a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);
    for (;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
}
 
void sub(bignum_t a,const bignum_t b){
    int i;
    for (i=1;i<=b[0];i++)
        if ((a[i]-=b[i])<0)
            a[i+1]--,a[i]+=DEPTH;
    for (;a[i]<0;a[i]+=DEPTH,i++,a[i]--);
    for (;!a[a[0]]&&a[0]>1;a[0]--);
}
 
void sub(bignum_t a,const int b){
    int i=1;
    for (a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
    for (;!a[a[0]]&&a[0]>1;a[0]--);
}
 
void sub(bignum_t a,const bignum_t b,const int c,const int d){
    int i,O=b[0]+d;
    for (i=1+d;i<=O;i++)
        if ((a[i]-=b[i-d]*c)<0)
            a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH;
    for (;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
    for (;!a[a[0]]&&a[0]>1;a[0]--);
}
 
void mul(bignum_t c,const bignum_t a,const bignum_t b){
    int i,j;
    memset((void*)c,0,sizeof(bignum_t));
    for (c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)
        for (j=1;j<=b[0];j++)
            if ((c[i+j-1]+=a[i]*b[j])>=DEPTH)
                c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH;
    for (c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);
}
 
void mul(bignum_t a,const int b){
    int i;
    for (a[1]*=b,i=2;i<=a[0];i++){
        a[i]*=b;
        if (a[i-1]>=DEPTH)
            a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH;
    }
    for (;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
    for (;!a[a[0]]&&a[0]>1;a[0]--);
}
 
void mul(bignum_t b,const bignum_t a,const int c,const int d){
    int i;
    memset((void*)b,0,sizeof(bignum_t));
    for (b[0]=a[0]+d,i=d+1;i<=b[0];i++)
        if ((b[i]+=a[i-d]*c)>=DEPTH)
            b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH;
    for (;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);
    for (;!b[b[0]]&&b[0]>1;b[0]--);
}
 
void div(bignum_t c,bignum_t a,const bignum_t b){
    int h,l,m,i;
    memset((void*)c,0,sizeof(bignum_t));
    c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1;
    for (i=c[0];i;sub(a,b,c[i]=m,i-1),i--)
        for (h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)
            if (comp(b,m,i-1,a)) h=m-1;
            else l=m;
    for (;!c[c[0]]&&c[0]>1;c[0]--);
    c[0]=c[0]>1?c[0]:1;
}
 
void div(bignum_t a,const int b,int& c){
    int i;
    for (c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);
    for (;!a[a[0]]&&a[0]>1;a[0]--);
}
 
void sqrt(bignum_t b,bignum_t a){
    int h,l,m,i;
    memset((void*)b,0,sizeof(bignum_t));
    for (i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)
        for (h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)
            if (comp(b,m,i-1,a)) h=m-1;
            else l=m;
    for (;!b[b[0]]&&b[0]>1;b[0]--);
    for (i=1;i<=b[0];b[i++]>>=1);
}
 
int length(const bignum_t a){
    int t,ret;
    for (ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++);
    return ret>0?ret:1;
}
 
int digit(const bignum_t a,const int b){
    int i,ret;
    for (ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);
    return ret%10;
}
 
int zeronum(const bignum_t a){
    int ret,t;
    for (ret=0;!a[ret+1];ret++);
    for (t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++);
    return ret;
}
 
void comp(int* a,const int l,const int h,const int d){
    int i,j,t;
    for (i=l;i<=h;i++)
        for (t=i,j=2;t>1;j++)
            while (!(t%j))
                a[j]+=d,t/=j;
}
 
void convert(int* a,const int h,bignum_t b){
    int i,j,t=1;
    memset(b,0,sizeof(bignum_t));
    for (b[0]=b[1]=1,i=2;i<=h;i++)
        if (a[i])
            for (j=a[i];j;t*=i,j--)
                if (t*i>DEPTH)
                    mul(b,t),t=1;
    mul(b,t);
}
 
void combination(bignum_t a,int m,int n){
    int* t=new int[m+1];
    memset((void*)t,0,sizeof(int)*(m+1));
    comp(t,n+1,m,1);
    comp(t,2,m-n,-1);
    convert(t,m,a);
    delete []t;
}
 
void permutation(bignum_t a,int m,int n){
    int i,t=1;
    memset(a,0,sizeof(bignum_t));
    a[0]=a[1]=1;
    for (i=m-n+1;i<=m;t*=i++)
        if (t*i>DEPTH)
            mul(a,t),t=1;
    mul(a,t);
}
 
#define SGN(x) ((x)>0?1:((x)<0?-1:0))
#define ABS(x) ((x)>0?(x):-(x))
 
int read(bignum_t a,int &sgn,istream& is=cin){
    char str[MAX*DIGIT+2],ch,*buf;
    int i,j;
    memset((void*)a,0,sizeof(bignum_t));
    if (!(is>>str)) return 0;
    buf=str,sgn=1;
    if (*buf=='-') sgn=-1,buf++;
    for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
        ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch;
    for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
    for (i=1;i<=a[0];i++)
        for (a[i]=0,j=0;j<DIGIT;j++)
            a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0';
    for (;!a[a[0]]&&a[0]>1;a[0]--);
    if (a[0]==1&&!a[1]) sgn=0;
    return 1;
}
 
struct bignum {
    bignum_t num;
    int sgn;
public:
    inline bignum(){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=0;}
    inline int operator!(){return num[0]==1&&!num[1];}
    inline bignum& operator=(const bignum& a){memcpy(num,a.num,sizeof(bignum_t));sgn=a.sgn;return *this;}
    inline bignum& operator=(const int a){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=SGN(a);add(num,sgn*a);return *this;};
    inline bignum& operator+=(const bignum& a){if(sgn==a.sgn)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_t t;
        memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=a.sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn;return *this;}
    inline bignum& operator+=(const int a){if(sgn*a>0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_t t;
        memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sgn=-sgn;sub(num,t);}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=SGN(a),add(num,ABS(a));return *this;}
    inline bignum operator+(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;}
    inline bignum operator+(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;}
    inline bignum& operator-=(const bignum& a){if(sgn*a.sgn<0)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_t t;
        memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)add(num,a.num),sgn=-a.sgn;return *this;}
    inline bignum& operator-=(const int a){if(sgn*a<0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_t t;
        memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=-SGN(a),add(num,ABS(a));return *this;}
    inline bignum operator-(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;}
    inline bignum operator-(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;}
    inline bignum& operator*=(const bignum& a){bignum_t t;mul(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn*=a.sgn;return *this;}
    inline bignum& operator*=(const int a){mul(num,ABS(a));sgn*=SGN(a);return *this;}
    inline bignum operator*(const bignum& a){bignum ret;mul(ret.num,num,a.num);ret.sgn=sgn*a.sgn;return ret;}
    inline bignum operator*(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));mul(ret.num,ABS(a));ret.sgn=sgn*SGN(a);return ret;}
    inline bignum& operator/=(const bignum& a){bignum_t t;div(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn;return *this;}
    inline bignum& operator/=(const int a){int t;div(num,ABS(a),t);sgn=(num[0]==1&&!num[1])?0:sgn*SGN(a);return *this;}
    inline bignum operator/(const bignum& a){bignum ret;bignum_t t;memcpy(t,num,sizeof(bignum_t));div(ret.num,t,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn;return ret;}
    inline bignum operator/(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);return ret;}
    inline bignum& operator%=(const bignum& a){bignum_t t;div(t,num,a.num);if (num[0]==1&&!num[1])sgn=0;return *this;}
    inline int operator%=(const int a){int t;div(num,ABS(a),t);memset(num,0,sizeof(bignum_t));num[0]=1;add(num,t);return t;}
    inline bignum operator%(const bignum& a){bignum ret;bignum_t t;memcpy(ret.num,num,sizeof(bignum_t));div(t,ret.num,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn;return ret;}
    inline int operator%(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);memset(ret.num,0,sizeof(bignum_t));ret.num[0]=1;add(ret.num,t);return t;}
    inline bignum& operator++(){*this+=1;return *this;}
    inline bignum& operator--(){*this-=1;return *this;};
    inline int operator>(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);}
    inline int operator>(const int a){return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);}
    inline int operator>=(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);}
    inline int operator>=(const int a){return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);}
    inline int operator<(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);}
    inline int operator<(const int a){return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);}
    inline int operator<=(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);}
    inline int operator<=(const int a){return sgn<0?(a<0?comp(num,-a)>=0:1):(sgn>0?(a>0?comp(num,a)<=0:0):a>=0);}
    inline int operator==(const bignum& a){return (sgn==a.sgn)?!comp(num,a.num):0;}
    inline int operator==(const int a){return (sgn*a>=0)?!comp(num,ABS(a)):0;}
    inline int operator!=(const bignum& a){return (sgn==a.sgn)?comp(num,a.num):1;}
    inline int operator!=(const int a){return (sgn*a>=0)?comp(num,ABS(a)):1;}
    inline int operator[](const int a){return digit(num,a);}
    friend inline istream& operator>>(istream& is,bignum& a){read(a.num,a.sgn,is);return is;}
    friend inline ostream& operator<<(ostream& os,const bignum& a){if(a.sgn<0)os<<'-';write(a.num,os);return os;}
    friend inline bignum sqrt(const bignum& a){bignum ret;bignum_t t;memcpy(t,a.num,sizeof(bignum_t));sqrt(ret.num,t);ret.sgn=ret.num[0]!=1||ret.num[1];return ret;}
    friend inline bignum sqrt(const bignum& a,bignum& b){bignum ret;memcpy(b.num,a.num,sizeof(bignum_t));sqrt(ret.num,b.num);ret.sgn=ret.num[0]!=1||ret.num[1];b.sgn=b.num[0]!=1||ret.num[1];return ret;}
    inline int length(){return ::length(num);}
    inline int zeronum(){return ::zeronum(num);}
    inline bignum C(const int m,const int n){combination(num,m,n);sgn=1;return *this;}
    inline bignum P(const int m,const int n){permutation(num,m,n);sgn=1;return *this;}
};
 
int stack[100];
bignum f[100];
int top;
 
bignum C(int n, int k)
{
    bignum ret;
    ret = 1;
    for (int i = n; i > n - k; i--)
        ret = ret * i / (n - i + 1);
    return ret;
}
 
bignum pow(int a)
{
    bignum ret;
    ret = 1;
    for (int i = 0; i < a; i++)
        ret *= 2;
    return ret;
}
 
void calc(int n)
{
    f[n] = 0;
    for (int i = 1; i < n; i++)
        f[n] += f[i] * f[n - i] * (pow(i) - 1) * C(n - 2, i - 1);
}
 
int main()
{
    f[1] = f[2] = 1;
    for (int i = 3; i <= 50; i++)
        calc(i);
    int n;
    while (scanf("%d", &n), n != 0)
        cout << f[n] << endl;
    return 0;
}
« Older Entries