JZOJ3626. 【POI2012】polarization

Description

今天，Bitotian char Bittard 寄给Byteotian king Byteasar 的信给公众开放了。Bitotia 要求整个Byteotia

使用Bit Polarizing Magnet（BPM，字面意思为“位极化磁铁” ）。如果使用了，BPM 会令Byteotia 中所有的每条路都变成单向通行。敌人知悉一个非常好的消息，这可以是Byteotia 简陋的基础建设的致命一击——每一对城镇间只有唯一一条的路径。

BPM 能将Byteotia 的基础建设破坏到多坏？计算当新的道路取向产生时，最小的和最大的其中一个城镇可以到达另一个城镇的城镇对数。

Input

输入的第一行给出单独一个整数n（1<= n <=250000），Byteotia 的城镇数。接下来的n - 1 行描述道路。每行有两个整数，u 和v（1 <= u <=v <= n），表明有一条道路（此时仍然为双向通行）直接连接第u 和第v 的城镇。

总值60% 的数据中，有附加条件n <= 10000；而且，其中总值30% 的数据满足n <=100。

Output

输出的唯一一行为两个整数。第一个数字应当是最小的，和第二个是最大的——道路定向之后仍连通的最大城镇对数。

Sample Input

输入1：

4

1 2

1 3

1 4

输入2：

8

1 2

2 3

3 4

4 5

5 6

6 7

7 8

Sample Output

输出1：

3 5

输出2：

7 28

Data Constraint

总值60% 的数据中，有附加条件n <= 10000；而且，其中总值30% 的数据满足n <=100。

题解

最小值是很简单的，

奇数层的方向和偶数层的方向相反，答案就是n-1了。

对于最大值，就要有点麻烦，需要一些结论。

一定有一个源点，所有的点要么连向它，要么它连向别人。

也就是所有的点通过这个源点，两两相互连通。

如果要最优，那么向上还有向下的边上应该尽量相近。

设一个dp

fi表示能否构成和为i,

这样的时间复杂度是不行的，

按照n√分类，

比n√大的就直接01背包，因为和是n-1，所以比n√大的个数不超过n√个。

比n√小的就按照余数分类。

这样总的复杂度就是O(nn√)

code

#include<queue>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include <cstring>
#include <string.h>
#include <cmath>
#include <math.h>
#include <time.h>
#define ll long long
#define N 250003
#define M 503
#define db double
#define P putchar
#define G getchar
#define inf 998244353
using namespace std;
char ch;
void read(int &n)
{
n=0;
ch=G();
while((ch<'0' || ch>'9') && ch!='-')ch=G();
ll w=1;
if(ch=='-')w=-1,ch=G();
while('0'<=ch && ch<='9')n=(n<<3)+(n<<1)+ch-'0',ch=G();
n*=w;
}

int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
ll abs(ll x){return x<0?-x:x;}
ll sqr(ll x){return x*x;}
void write(ll x){if(x>9) write(x/10);P(x%10+'0');}

int lst
,nxt[N*2],to[N*2],n,m,w,x,y,tot,mx,pos;
int q
,size
,t,v[M],s;
bool bz
,f
,g
;
ll ans,sum;

void ins(int x,int y)
{
nxt[++tot]=lst[x];
to[tot]=y;
lst[x]=tot;
}

void bfs(int x)
{
memset(bz,1,sizeof(bz));
bz[q[1]=x]=0;
int i=0,j=1;
while(i<j)
{
x=q[++i];
for(int k=lst[x];k;k=nxt[k])
if(bz[to[k]])bz[q[++j]=to[k]]=0;
}
}

int main()
{
freopen("polarization.in","r",stdin);
freopen("polarization.out","w",stdout);
read(n);m=sqrt(n);w=n>>1;
for(int i=1;i<n;i++)
read(x),read(y),ins(x,y),ins(y,x);

bfs(1);
mx=n+1;
memset(size,0,sizeof(size));
for(int i=n;i;i--)
{
size[q[i]]=1;t=0;
for(int j=lst[q[i]];j;j=nxt[j])
size[q[i]]+=size[to[j]],t=max(t,size[to[j]]);
t=max(t,n-size[q[i]]);
if(t<mx)mx=t,pos=q[i];
}

bfs(pos);
memset(size,0,sizeof(size));
for(int i=n;i;i--)
{
size[q[i]]=1;t=0;
for(int j=lst[q[i]];j;j=nxt[j])
size[q[i]]+=size[to[j]],t=max(t,size[to[j]]);
ans+=size[q[i]];
}

memset(f,0,sizeof(f));
f[mx=0]=1;
for(int i=lst[pos];i;i=nxt[i])
{
if(size[to[i]]<m)
{
v[size[to[i]]]++;
continue;
}
mx+=size[to[i]];
mx=mx<w?mx:w;
for(int j=mx;j>=size[to[i]];j--)
f[j]=f[j]|f[j-size[to[i]]];
if(f[w])break;
}

for(int i=1;i<=m;i++)
{
if(f[w])break;
if(!v[i])continue;
memset(g,0,sizeof(g));
for(int j=0;j<i;j++)
{
s=0;
for(int k=0;k*i+j<=w;k++)
{
s+=f[i*k+j];
g[i*k+j]=s;
if(k>=v[i])s-=f[(k-v[i])*i+j];
}
}
memcpy(f,g,sizeof(f));
}

for(int i=0;i<=n;i++)
if(f[i])sum=max(sum,(ll)(n-1-i)*i);

ans+=sum-n;

write(n-1);P(' ');write(ans);
}