【BZOJ1791】【IOI2008】【基环树】island(status第一速度)





1791: [Ioi2008]Island 岛屿 

Time Limit: 20 Sec  Memory Limit: 162 MB
Submit: 908  Solved: 159
[Submit][Status]

Description

你将要游览一个有N个岛屿的公园。从每个岛i出发,仅仅建造一座桥。桥的长度以Li表示。公园内总共同拥有N座桥。

虽然每座桥由一个岛连到还有一个岛。但每座桥均能够双向行走。同一时候,每一对这样的岛屿。都有一艘专用的往来两岛之间的渡船。

 相对于乘船而言,你更喜欢步行。

你希望所经过的桥的总长度尽可能的长,但受到下面的限制。 • 能够自行挑选一个岛開始游览。 • 不论什么一个岛都不能游览一次以上。 • 不管不论什么时间你都能够由你如今所在的岛S去还有一个你从未到过的岛D

SD能够有下面方法: 步行:仅当两个岛之间有一座桥时才有可能。对于这样的情况。桥的长度会累加到你步行的总距离;或者 渡船:你能够选择这样的方法,仅当没有不论什么桥和/或曾经使用过的渡船的组合能够由S走到D(当检查是否可到达时,你应该考虑全部的路径。包含经过你曾游览过的那些岛)。 注意,你不必游览全部的岛,也可能无法走全然部的桥。

 任务 编写一个程序,给定N座桥以及它们的长度。依照上述的规则,计算你能够走过的桥的最大长度。

 限制 2 <= N <= 1,000,000 公园内的岛屿数目。 1<= Li <= 100,000,000 i的长度。 

Input

• 第一行包括N个整数。即公园内岛屿的数目。岛屿由1N编号。 • 随后的N行每一行用来表示一个岛。

行由两个以单空格分隔的整数,表示由岛i筑的桥。第一个整数表示桥还有一端的岛,第二个整数表示该桥的长度Li。你能够如果对於每座桥,其端点总是位于不同的岛上。

 

Output

你的程序必须向标准输出写出包括一个整数的单一行。就可以能的最大步行距离。 注1:对某些測试。答案可能无法放进32-bit整数。你要取得这道题的满分,可能须要用Pascalint64C/C++long long类型。 注2:在比赛环境执行Pascal程序,由标准输入读入64-bit数据比32-bit数据要慢得多,即使被读取的数据能够32-bit表示。

我们建议把输入数据读入到32-bit数据类型。 评分 N不会超过4,000。 

Sample Input

7
 3 8
 7 2
 4 2
 1 4
 1 9
 3 4
 2 3

Sample Output

24

/******************************************************************************/

题意:

输入n,然后n行第i行是由i向外引一条无向边,以及输入边的权值。这样会组成k个联通图,每一个图上取两点。使其间路径长度最大,求这些“最大路径”长度总和。

 

题目分析:

首先一个n点联通图上会有n条边,而它又联通,全部它一定是有环的,由于有n-1条边的n点联通图保证联通且无环,剩下一条边则一定使“树”中有且仅仅有一个环,于是得证每一个联通图都是一个“基环树”,即有且仅有一个环的树。

那么如今我们应该输出的就是全部基环树的直径总和(树的直径即树上点不反复的最长路径)。

 

如图,这棵基环树的直径就是11到5。经过3。长度71。

题解:

我们须要对每一个基环树单独处理,先搜到它的环,然后dfs求每一个环上点往外枝杈的最长路径,这样每一个点就有了一个权值。然后环上每一个边又有了一个权值。就能够在环上做一发单调队列动规,求基环树直径长度啦!

当然,我们对于每棵树的直径是在动规里面定论的。只是它的初值却不能在动规前赋成0

例如以下图中。直径就不经过环。为136,长度79,所以在dfs求环上点权的,也不能忘了更新直径值,只是怎么更新就须要略加斟酌了。

 

实现:

首先双向建边,然后对随意点搜索,搜到某个点已经搜过了,就代表这个点是环上的,然后处理环。再然后就是搜索找到每一个点。然后递归出枝杈边权和最长值。作为点权值,进行单调队列优化后的动规,过程中更新直径长度。单调队列把点倍增,然后两点间长度小于环长度就可以。

我在此证明一下动规的单调性。【甚水,可略过】首先设点ABCD依次排列,则从AD(有向。不能从DA)的长度为环上AD的长度和加上AD点权和。

不要问我为什么不能从DA。由于我已经把点倍增了,从D到第二个A就是“从DA”了。

好吧。跑题了。我来总结一下,

长度AD = A点权+A~B边长+B~C边长+C~D边长+D点权

那么长度BD就 = B点权+B~C边长+C~D边长+D点权

发生了什么?什么?仅仅要B点权 > A点权+A~B边长,那么从BD就比AD优!

同理。后面的一样。

结果出来了。然后输出就可以,注意输入要用int,输出用long long。不然会超时,超非常多,IOI2008測试数据中isl18f.in秒出解。可是用long long 读入,呵呵呵呵。

时间丶代码复杂度优化:

找环实现非常烦非常磨叽对不正确?这时候我们能够引入一种新的解决方法,类似于最小树形图找环的实现(上文的实现方法我事实上AC前并不知道)。

眼下BZOJ排名第一你怕不怕?常数再好好写写还能更快你怕不怕?就问你怕不怕?

这里就须要运用到本题的一些性质。

首先我们能够把数据输入时的边方向当成正方向,其反方向。好吧。“当成”反方向。这样每一个点都有且仅有一条出边。然后我们从随意一个点開始遍历。假设没有环。那是不是根本停不下来?!而数据又是有限的。所以最后就一定会连到已有的链上的某点,而非常好想,这个点向前遍历,最后会回到这个点上,即它是一个环,而之前的点的出边方向都是在向环推进。这时候我们再把其他点挨个遍历,首先同一个联通图是一定不会有俩环的,所以要想改变“根本停不下来”的现状。新点遍历到最后。就一定会指向某个已经遍历过的点,从而连上了环,或者方向是向环的。

这样我们能够把数据输入的方向存为next[i]。然后把长度存为len[i]。而反向边则有邻接表存储(讨厌指针的我写的是链式前向星)。

这样我们仅仅须要遍历随意点,通过next标记沿途全部点,然后遍历到一个已标记点,即能够快速找到基环树的环了。然后我们对环上每一个点进行“-1”标记,禁止接下来的dfs找到该点(反边存了环上的边),从而能够再接下来的dfs中顺利给环上每一个点赋值(找枝杈,递归求最长长度)。

优化到此结束,接下来的单调队列与一般做法无异了。

注意:

本题dfs递归出解时因为层数过深可能爆系统栈,所以须要写一份非递归版自写栈的dfs。我会在后面代码附上凝视掉的递归版dfs以利于理解思想。(不要想着开大系统栈!

那还不如手写非递归dfs呢。)

/**************************************************************
    Problem: 1791
    User: 18357
    Language: C++
    Result: Accepted
    Time:11052 ms
    Memory:120100 kb
****************************************************************/
 
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
#include <iostream>
#define N 1050000
using namespace std;
struct Syndra
{
    int u,v,len,next;
}e[N];
struct Fiona
{
    int edge,flag1,flag2;
    long long temp,max1,max2;
}s[N];
int head[N],cnt,n;
int visit[N],next[N],len[N];
int i,j,k;
long long sa[N],pre[N],ans;
void add(int u,int v,int len)
{
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].len=len;
    e[cnt].next=head[u];
    head[u]=cnt;
}
int que[N<<1];
long long sum[N<<1],ret;
long long dp(int num)
{
    int top,tail;
    int u,b,star;
    int et;
    for(et=1;et<(num<<1);et++)
    {
        sum[et]=sum[et-1]+pre[(et-1)>=num?(et-1-num):(et-1)];
    }
    top=tail=0;
     
    que[top]=0;
    for(et=1;et<(num<<1);et++)
    {
        while(et-que[top]>=num)top++;
        u=que[top];
        ret=max(ret,sa[et>=num?et-num:et]+sa[u>=num?

u-num:u]+sum[et]-sum[u]); b=que[tail]; que[++tail]=et; for(star=tail;star>top;b=que[star-1]) { if(sum[et]-sum[b]+sa[b>=num?b-num:b]<sa[et>=num?et-num:et]) { que[star]=b; que[--star]=et; } else break; } tail=star; } /*que[tail++]=0; for(et=1;et<(num<<1);++et) { while(top<tail&&et-que[top]>=num)++top; u=que[top]; ret=max(ret,sa[et>=num?

et-num:et]+sa[u>=num?u-num:u]+sum[et]-sum[u]); while(top<tail&&sa[et>=num?

et-num:et]>=sa[que[tail-1]>=num?

que[tail-1]-num:que[tail-1]]+sum[et]-sum[que[tail-1]])--tail; que[tail++]=et; }*/ return ret; } void build() { cnt=1; memset(head,0,sizeof(head)); memset(visit,0,sizeof(visit)); scanf("%d",&n); for(i=1;i<=n;i++) { scanf("%d%d",&next[i],&len[i]); add(next[i],i,len[i]); } } stack<int>sk; int fa[N]; void dfs(int x) { if(s[x].edge==0) { sk.pop(); if(s[x].flag2)ret=max(ret,s[x].max1+s[x].max2); if(visit[x]==-1) return ; x = sk.top(); { int v,tt=s[x].edge; v=e[tt].v; visit[v]=i; s[x].temp=s[v].max1+e[tt].len; if(s[x].max1<s[x].temp) { if(s[x].flag1)s[x].max2=s[x].max1,s[x].flag2=1; else s[x].flag1=1; s[x].max1=s[x].temp; } else if(s[x].max2<s[x].temp)s[x].max2=s[x].temp,s[x].flag2=1; s[x].edge=e[tt].next; } return ; } int v,tt=s[x].edge; v=e[tt].v; if(visit[v]==-1) { s[x].edge=e[tt].next; return ; } fa[v]=x; s[v].edge=head[v]; sk.push(v); } long long handle(int x) { s[x].edge=head[x]; sk.push(x); while(!sk.empty()) { dfs(sk.top()); } return s[x].max1; }/*handle(long long)+dfs(void)=dfs(long long)*/ /*long long dfs(int x) { int et,v,flag1,flag2; long long max1,max2; for(max1=max2=0,flag1=flag2=0,et=head[x];et;et=e[et].next) { v=e[et].v; if(visit[v]==-1)continue; temp=dfs(v)+e[et].len; visit[v]=i; if(max1<temp) { if(flag1)max2=max1,flag2=1; max1=temp; flag1=1; } else if(max2<temp)max2=temp,flag2=1; } if(flag2)ret=max(ret,max1+max2); return max1; }*/ int main() { // freopen("isl.in","r",stdin); // freopen("isl.out","w",stdout); int u,v; build(); for(i=1;i<=n;i++) { if(!visit[i]) { for(u=i;!visit[u];u=next[u]) { visit[u]=i; } if(visit[u]==i) { ret=0;cnt=0; visit[u]=-1; for(v=next[u];v!=u;v=next[v]) { visit[v]=-1; } v=u; do{ pre[cnt]=len[v]; sa[cnt++]=handle(v); v=next[v]; }while(v!=u); ans+=dp(cnt); } } } cout<<ans; return 0; } 

以下是读入优化后的代码,这年头,你不读入优化,光输入就得比这代码慢啊~

/**************************************************************
    Problem: 1791
    User: 18357
    Language: C++
    Result: Accepted
    Time:4556 ms
    Memory:120132 kb
****************************************************************/
 
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
#include <cctype>
#include <iostream>
#define N 1050000
using namespace std;
inline int getc() {
    static const int L = 1<<15;
    static char buf[L],*S=buf,*T=buf;
    if(S==T){
        T=(S=buf)+fread(buf,1,L,stdin);
        if(S==T)return EOF;
    }
    return *S++;
}
inline int getint() {
    int c;
    while(!isdigit(c = getc()));
    int tmp = c-'0';
    while(isdigit(c=getc()))
        tmp=(tmp<<1)+(tmp<<3)+c-'0';
    return tmp;
}
struct Syndra
{
    int u,v,len,next;
}e[N];
struct Fiona
{
    int edge,flag1,flag2;
    long long temp,max1,max2;
}s[N];
int head[N],cnt,n;
int visit[N],next[N],len[N];
int i,j,k;
long long sa[N],pre[N],ans;
void add(int u,int v,int len)
{
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].len=len;
    e[cnt].next=head[u];
    head[u]=cnt;
}
int que[N<<1];
long long sum[N<<1],ret;
long long dp(int num)
{
    int top,tail;
    int u,b,star;
    int et;
    for(et=1;et<(num<<1);et++)
    {
        sum[et]=sum[et-1]+pre[(et-1)>=num?(et-1-num):(et-1)];
    }
    top=tail=0;
    /*
    que[top]=0;
    for(et=1;et<(num<<1);et++)
    {
        while(et-que[top]>=num)top++;
        u=que[top];
        ret=max(ret,sa[et>=num?et-num:et]+sa[u>=num?

u-num:u]+sum[et]-sum[u]); b=que[tail]; que[++tail]=et; for(star=tail;star>top;b=que[star-1]) { if(sum[et]-sum[b]+sa[b]<sa[et]) { que[star]=b; que[--star]=et; } else break; } tail=star; } */ que[tail++]=0; for(et=1;et<(num<<1);++et) { while(top<tail&&et-que[top]>=num)++top; u=que[top]; ret=max(ret,sa[et>=num?et-num:et]+sa[u>=num?u-num:u]+sum[et]-sum[u]); while(top<tail&&sa[et>=num?et-num:et]>=sa[que[tail-1]>=num?

que[tail-1]-num:que[tail-1]]+sum[et]-sum[que[tail-1]])--tail; que[tail++]=et; } return ret; } void build() { cnt=1; memset(head,0,sizeof(head)); memset(visit,0,sizeof(visit)); n=getint(); for(i=1;i<=n;i++) { next[i]=getint(); len[i]=getint(); add(next[i],i,len[i]); } } stack<int>sk; int fa[N]; void dfs(int x) { if(s[x].edge==0) { sk.pop(); if(s[x].flag2)ret=max(ret,s[x].max1+s[x].max2); if(visit[x]==-1) return ; x = sk.top(); { int v,tt=s[x].edge; v=e[tt].v; visit[v]=i; s[x].temp=s[v].max1+e[tt].len; if(s[x].max1<s[x].temp) { if(s[x].flag1)s[x].max2=s[x].max1,s[x].flag2=1; else s[x].flag1=1; s[x].max1=s[x].temp; } else if(s[x].max2<s[x].temp)s[x].max2=s[x].temp,s[x].flag2=1; s[x].edge=e[tt].next; } return ; } int v,tt=s[x].edge; v=e[tt].v; if(visit[v]==-1) { s[x].edge=e[tt].next; return ; } fa[v]=x; s[v].edge=head[v]; sk.push(v); } long long handle(int x) { s[x].edge=head[x]; sk.push(x); while(!sk.empty()) { dfs(sk.top()); } return s[x].max1; }/*handle(long long)+dfs(void)=dfs(long long)*/ /*long long dfs(int x) { int et,v,flag1,flag2; long long max1,max2; for(max1=max2=0,flag1=flag2=0,et=head[x];et;et=e[et].next) { v=e[et].v; if(visit[v]==-1)continue; temp=dfs(v)+e[et].len; visit[v]=i; if(max1<temp) { if(flag1)max2=max1,flag2=1; max1=temp; flag1=1; } else if(max2<temp)max2=temp,flag2=1; } if(flag2)ret=max(ret,max1+max2); return max1; }*/ int main() { int u,v; build(); for(i=1;i<=n;i++) { if(!visit[i]) { for(u=i;!visit[u];u=next[u]) { visit[u]=i; } if(visit[u]==i) { ret=0;cnt=0; visit[u]=-1; for(v=next[u];v!=u;v=next[v]) { visit[v]=-1; } v=u; do{ pre[cnt]=len[v]; sa[cnt++]=handle(v); v=next[v]; }while(v!=u); ans+=dp(cnt); } } } cout<<ans; return 0; }

版权声明:本文博主原创文章。博客,未经同意不得转载。

posted @ 2015-09-30 20:47  lcchuguo  阅读(392)  评论(0编辑  收藏  举报