Keeping On Track

题目描述

Acmar and Ibmar are at war! You are in charge of a rail network that transports important supplies throughout the great state of Acmar during this delicate time. The rail system is made up of a set of rail lines which meet at various junction points. While there is no limit to the number of rail lines that can meet at a junction, the network is set up so that there is only one path between any two junctions. You’ve tried to argue for some redundancy in the system, i.e., extra rail lines so that there are two or more paths connecting some junctions, but it’s wartime and budgets are tight.

However, this may soon change as you’ve just been given some terrible news from double agents working in Ibmar: within the next month enemy spies plan to blow up one of the junctions! Unfortunately, the exact junction is not known, but knowing your enemy well you are certain that they will undoubtedly strike the critical junction, specifically the junction whose removal disconnects the most pairs of other remaining junctions in the system. You don’t have much time to act, so the most you can do is add one new line connecting two currently unconnected junctions, thereby reducing the number of disconnected pairs after the critical junction has been destroyed. Your job is to determine how to make the number of disconnected pairs as small as possible by adding in the best possible rail line.

 

输入

Input starts with a line containing an integer n (2 ≤ n ≤ 10 000) indicating the number of rail lines in the system. Following that are n lines of the form i1 i2 indicating that a rail line connects junctions i1 and i2. Junctions are numbered consecutively starting at 0. All rail lines are two-way and no rail line appears more than once in the input. There is exactly one path between any two junction points given in the input.

 

输出

Display two values n1 and n2, where n1 is the number of pairs of junctions which will be disconnected when the enemy destroys the critical junction, and n2 is the number of pairs of junctions still disconnected after you add in the best possible rail line. There will never be more than one critical junction.

 

样例输入

6
0 1
1 2
2 3
2 4
4 5
4 6

 

样例输出

11 5

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxn=10050;
int n,critical=-1,maxpair=-1;
int head[maxn],tot;
bool  vis[maxn];
struct node
{
    int u,v,nextt;
}edge[10050*2];
void addedge(int u,int v)
{
    edge[++tot].u=u;
    edge[tot].v=v;
    edge[tot].nextt=head[u];
    head[u]=tot;
}
int dfs(int u)
{
    int v,ans=1;
    vis[u]=1;
    for(int i=head[u];i;i=edge[i].nextt)
    {
        v=edge[i].v;
        if(!vis[v])
        {
            ans+=dfs(v);
        }
    }
    return ans;
}
int dfs2(int u)
{
    int v,ans=0,son=0;
    vis[u]=1;
    for(int i=head[u];i;i=edge[i].nextt)
    {
        v=edge[i].v;
        if(!vis[v])
        {
            int tmp=dfs2(v);
            ans+=tmp*(n-tmp);
            son+=tmp;
        }
    }
    ans+=(n-son)*son;
    ans/=2;
    if(ans>maxpair)
    {
        maxpair=ans;
        critical=u;
    }
    return son+1;
}
int main()
{
    int u,v;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d %d",&u,&v);
        addedge(u,v);
        addedge(v,u);
    }
    dfs2(0);
    memset(vis,0,sizeof(vis));
    vis[critical]=1;
    int fir=0,sec=0;
    for(int i=head[critical];i;i=edge[i].nextt)
    {
        v=edge[i].v;
        if(!vis[v])
        {
            int tmp=dfs(v);
            if(tmp>fir)
            {
                sec=fir;
                fir=tmp;
            }
            else if(tmp>sec)
            {
                sec=tmp;
            }
        }
    }
    printf("%d %d\n",maxpair,maxpair-fir*sec);
    return 0;
}