codeforce23 E. Tree（高精度+树形dp）

E. Tree

状态表示：$f_{u,j}$表示以$u$节点的子树，$u$所在连通块大小为$j$时，并且没有算上$u$连通块的贡献的最大值
状态计算：
对于一棵子树$v$来说，显然可以有两种情况

• $u$节点与$v$节点不连通：$f_{u,j}=f_{u,j}\times \max [f_{v,1\to s{z}_v}\times (1\to s{z}_v)]$
• $u$节点与$v$节点连通：$f_{u,j+k}=f_{u,j}\times f_{v,k}$

而答案就是$\max [f_{1,1\to s{z}_1}\times (1\to s{z}_1)]$（1是根节点，乘的这部分$1\to s{z}_1$是该节点所在连通块的贡献）

---

你以为完了???不不不，还要写个高精度！！！

#define IO ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0)
#pragma GCC optimize(2)
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
//==========================================================高精度板子
struct bign
{
	int d[120], len;
	bign() { memset(d, 0, sizeof d); len = 1; }
	bign(int num) { *this = num; }
	bign(char* num) { *this = num; }
	bign operator=(const char* num)
	{
		len = strlen(num);
		for (int i = 0; i < len; i++) d[i] = num[len - i - 1] - '0';
		return *this;
	}
	bign operator=(int num)
	{
		char c[1010];
		sprintf(c, "%d", num);
		*this = c;
		return *this;
	}
	void clear()
	{
		while (len > 1 && !d[len - 1]) len--;
	}
	bign operator+(const bign& b)
	{
		bign c; c.len = 0;
		for (int i = 0, t = 0; t || i < len || i < b.len; i++)
		{
			if (i < len) t += d[i];
			if (i < b.len) t += b.d[i];
			c.d[c.len++] = t % 10;
			t /= 10;
		}
		return c;
	}
	bign operator-(const bign& b)
	{
		bign c; c.len = 0;
		for (int i = 0, t = 0; i < len; i++)
		{
			t += d[i];
			if (i < b.len) t -= b.d[i];
			c.d[c.len++] = (t + 10) % 10;
			if (t >= 0) t = 0;
			else t = -1;
		}
		c.clear();
		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.d[i + j] += d[i] * b.d[j];
		for (int i = 0; i < c.len - 1; i++) c.d[i + 1] += c.d[i] / 10, c.d[i] %= 10;
		c.clear();
		return c;
	}
	bool operator < (const bign& b)
	{
		if (len != b.len) return len < b.len;
		for (int i = len - 1; i >= 0; i--)
			if (d[i] != b.d[i]) return d[i] < b.d[i];
		return false;
	}
	bool operator <= (const bign& b)
	{
		if (len != b.len) return len < b.len;
		for (int i = len - 1; i >= 0; i--)
			if (d[i] != b.d[i]) return d[i] < b.d[i];
		return true;
	}
	bool operator > (const bign& b)
	{
		if (len != b.len) return len > b.len;
		for (int i = len - 1; i >= 0; i--)
			if (d[i] != b.d[i]) return d[i] > b.d[i];
		return false;
	}
	bool operator >= (const bign& b)
	{
		if (len != b.len) return len > b.len;
		for (int i = len - 1; i >= 0; i--)
			if (d[i] != b.d[i]) return d[i] > b.d[i];
		return true;
	}
	bign operator+=(const bign& b)
	{
		*this = *this + b;
		return *this;
	}
	bign operator-=(const bign& b)
	{
		*this = *this - b;
		return *this;
	}
	bign operator*=(const bign& b)
	{
		*this = *this * b;
		return *this;
	}
	void print()
	{
		for (int i = len - 1; i >= 0; i--) std::cout << d[i];
		cout << '\n';
	}
	string str()
	{
		string res = "";
		for (int i = 0; i < len; i++) res = (char)(d[i] + '0') + res;
		return res;
	}
};
istream& operator >>(istream& in, bign& x)
{
	string s;
	in >> s;
	x = s.c_str();
	return in;
}
ostream& operator <<(ostream& out, bign& x)
{
	out << x.str();
	return out;
};
bign max(bign a,bign b)
{
    return a>b?a:b;
}
//==========================================================
constexpr int N=710;
int h[N],e[2*N],ne[2*N],idx;
void add(int a,int b){e[idx]=b,ne[idx]=h[a],h[a]=idx++;}
int sz[N],n;
bign f[N][N],ans;
void dfs(int u,int fa)
{
    f[u][1]=1;
    sz[u]=1;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int v=e[i];
        if(v==fa) continue;
        dfs(v,u);
        bign now=1;
        for(int j=1;j<=sz[v];j++) now=max(now,f[v][j]*bign(j));
        
        for(int j=sz[u];j>=1;j--)
        {
            for(int k=sz[v];k>=1;k--)
                    f[u][j+k]=max(f[u][j+k],f[u][j]*f[v][k]);  
            f[u][j]=f[u][j]*now;    
        }
        sz[u]+=sz[v];
    }
    for(int j=1;j<=sz[u];j++)
        ans=max(ans,f[u][j]*bign(j));
}
int main()
{
    cin>>n;
    memset(h,-1,sizeof h);
    for(int i=1;i<n;i++)
    {
        int u,v;
        cin>>u>>v;
        add(u,v),add(v,u);
    }
    dfs(1,0);
    ans.print();
    return 0;
}

一下午搞了个这个题，顺便整理了一下高精度摸吧yep！
要加油哦~