CodeForces 23 E.Tree（树形DP+高精度）

Description

给出一棵$n$个节点的树，可以断掉任意数量的边把树分成若干连通分支，问所得连通分支点数乘积最大值

Input

第一行一整数$n$表示点数，之后$n-1$行每行两个整数$u,v$表示一条树边$(1\le n\le 700)$

Output

输出断掉任意数量的边后所得各个连通分支点数乘积最大值

Sample Input

5
1 2
2 3
3 4
4 5

Sample Output

6

Solution

树形$DP$，对于一点$u$，有两种选择，要么断掉$u$和父亲的边，要么带着若干以$u$为根的子树中的节点并到其父亲所在连通分支中，以$dp[u][i]$表示$u$带着以$u$为根的子树中的$i$个节点并到其父亲所在连通分支后，其子树中剩余节点所能得到的最大答案，$i=0$时表示断掉了$u$和其父亲之间的边，若以$1$为根，那么答案即为$dp[1][0]$

对于$u$节点，一个个考虑其儿子节点，假设当前考虑其某个儿子节点$v$，有转移$dp[u][i+j]=max(dp[i+j],dp[u][i]*dp[v][j])$，在求出所有的$dp[u][i](i>0)$后，即得到了$u$带走$i$个节点后剩余节点的最大值，$u$如果要断掉和父亲的边，那么对答案的贡献就是$i$，故有$dp[u][0]=max(i*dp[u][i])$

注意答案很大要用高精度

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f,maxn=707;
struct BigInt
{
    const static int mod=10000;
    const static int LEN=4;
    int a[80],len;
    BigInt() 
    {
        memset(a,0,sizeof(a));
        len=1;
    }
    void init(int x)
    {
        memset(a,0,sizeof(a));
        len=0;
        do
        {
            a[len++]=x%mod;
            x/=mod;
        }while(x);
    }
    void Init(const char s[])
    {
        memset(a,0,sizeof(a));
        int l=strlen(s),res=0;
        len=l/LEN;
        if(l%LEN)len++;
        for(int i=l-1;i>=0;i-=LEN)
        {
            int t=0,k=max(i-LEN+1,0);
            for(int j=k;j<=i;j++)t=t*10+s[j]-'0';
            a[res++]=t;
        }
    }
    int Compare(const BigInt &b)
    {
        if(len<b.len)return -1;
        if(len>b.len)return 1;
        for(int i=len-1;i>=0;i--)
            if(a[i]<b.a[i])return -1;
            else if(a[i]>b.a[i])return 1;
        return 0;
    }
    BigInt operator *(const BigInt &b)const
    {
        BigInt ans;
        for(int i=0;i<len;i++)
        {
            int k=0;
            for(int j=0;j<b.len;j++)
            {
                int temp=a[i]*b.a[j]+ans.a[i+j]+k;
                ans.a[i+j]=temp%mod;
                k=temp/mod;
            }
            if(k!=0)ans.a[i+b.len]=k;
        }
        ans.len=len+b.len;
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
        return ans;
    }
    void output()
    {
        printf("%d",a[len-1]);
        for(int i=len-2;i>=0;i--)
            printf("%04d",a[i]);
        printf("\n");
    }
}dp[maxn][maxn],a[maxn];
int n,Size[maxn];
vector<int>g[maxn];
void dfs(int u,int fa)
{
    Size[u]=1;
    for(int i=0;i<=n;i++)dp[u][i].init(1);
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(v==fa)continue;
        dfs(v,u);
        BigInt temp;
        for(int j=Size[u];j>=0;j--)
            for(int k=Size[v];k>=0;k--)
            {
                temp=dp[u][j]*dp[v][k];
                if(temp.Compare(dp[u][j+k])>0)dp[u][j+k]=temp;
            }
        Size[u]+=Size[v];
    }
    for(int i=1;i<=Size[u];i++)
    {
        BigInt temp=dp[u][i]*a[i];
        if(dp[u][0].Compare(temp)<0)dp[u][0]=temp;
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)a[i].init(i);
    for(int i=1;i<n;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        g[u].push_back(v),g[v].push_back(u);
    }
    dfs(1,1);
    dp[1][0].output();
    return 0;
}