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
$f_i$表示能否构成和为i,
这样的时间复杂度是不行的，
按照$\sqrt n$分类，
比$\sqrt n$大的就直接01背包，因为和是n-1，所以比$\sqrt n$大的个数不超过$\sqrt n$个。
比$\sqrt n$小的就按照余数分类。
这样总的复杂度就是$O(n\sqrt n)$

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[N],nxt[N*2],to[N*2],n,m,w,x,y,tot,mx,pos;
int q[N],size[N],t,v[M],s;
bool bz[N],f[N],g[N];
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);
}