BZOJ2212: [Poi2011]Tree Rotations

2212: [Poi2011]Tree Rotations

Time Limit: 20 Sec Memory Limit: 259 MB
Submit: 391 Solved: 127
[Submit][Status]

Description

Byteasar the gardener is growing a rare tree called Rotatus Informatikus. It has some interesting features: The tree consists of straight branches, bifurcations and leaves. The trunk stemming from the ground is also a branch. Each branch ends with either a bifurcation or a leaf on its top end. Exactly two branches fork out from a bifurcation at the end of a branch - the left branch and the right branch. Each leaf of the tree is labelled with an integer from the range . The labels of leaves are unique. With some gardening work, a so called rotation can be performed on any bifurcation, swapping the left and right branches that fork out of it. The corona of the tree is the sequence of integers obtained by reading the leaves' labels from left to right. Byteasar is from the old town of Byteburg and, like all true Byteburgers, praises neatness and order. He wonders how neat can his tree become thanks to appropriate rotations. The neatness of a tree is measured by the number of inversions in its corona, i.e. the number of pairs（I,j）, (1< = I < j < = N ) such that(Ai>Aj) in the corona(A1,A2,A3…An). The original tree (on the left) with corona(3,1,2) has two inversions. A single rotation gives a tree (on the right) with corona(1,3,2), which has only one inversion. Each of these two trees has 5 branches. Write a program that determines the minimum number of inversions in the corona of Byteasar's tree that can be obtained by rotations.

现在有一棵二叉树，所有非叶子节点都有两个孩子。在每个叶子节点上有一个权值(有n个叶子节点，满足这些权值为1..n的一个排列)。可以任意交换每个非叶子节点的左右孩子。
要求进行一系列交换，使得最终所有叶子节点的权值按照遍历序写出来，逆序对个数最少。

Input

In the first line of the standard input there is a single integer (2< = N < = 200000) that denotes the number of leaves in Byteasar's tree. Next, the description of the tree follows. The tree is defined recursively: if there is a leaf labelled with ()(1<=P<=N) at the end of the trunk (i.e., the branch from which the tree stems), then the tree's description consists of a single line containing a single integer , if there is a bifurcation at the end of the trunk, then the tree's description consists of three parts: the first line holds a single number , then the description of the left subtree follows (as if the left branch forking out of the bifurcation was its trunk), and finally the description of the right subtree follows (as if the right branch forking out of the bifurcation was its trunk).

第一行n
下面每行，一个数x
如果x==0，表示这个节点非叶子节点，递归地向下读入其左孩子和右孩子的信息，
如果x!=0，表示这个节点是叶子节点，权值为x

1<=n<=200000

Output

In the first and only line of the standard output a single integer is to be printed: the minimum number of inversions in the corona of the input tree that can be obtained by a sequence of rotations.

一行，最少逆序对个数

Sample Input

3
0
0
3
1
2

Sample Output

HINT

Source

题解：

我的做法是这样的：（虽然被卡成翔。。。）

因为左子树+右子树构成的逆序对=左子树内部的逆序对+右子树内部的逆序对+左子树与右子树之间的逆序对

而前两部分仅通过交换左右子树是不会改变的，所以我们只要贪心的去看交换后左右子树之间的逆序对是否会减少就行，

减少了就交换，然后递归下去解决左子树和右子树。

在这个过程中我们用了一种方法，类似于NOI2007货币交换的方法，

先用 x 排序，然后就可以 O(n)算出逆序对，

然后按 y 分为两部分，递归下去

然后按 x 将两部分归并回来，使得仍保持原数组有序。

然后交上去T成翔啊。。。

想了想忽然发现这是会被卡成o(n^2)的啊！如果这棵树极度不平衡！

先贴上我的代码，然后去膜拜题解。。。

 1 #include<cstdio>
 2 #include<cstdlib>
 3 #include<cmath>
 4 #include<cstring>
 5 #include<algorithm>
 6 #include<iostream>
 7 #include<vector>
 8 #include<map>
 9 #include<set>
10 #include<queue>
11 #include<string>
12 #define inf 1000000000
13 #define maxn 1000000+10000
14 #define maxm 500+100
15 #define eps 1e-10
16 #define ll long long
17 #define pa pair<int,int>
18 #define for0(i,n) for(int i=0;i<=(n);i++)
19 #define for1(i,n) for(int i=1;i<=(n);i++)
20 #define for2(i,x,y) for(int i=(x);i<=(y);i++)
21 #define for3(i,x,y) for(int i=(x);i>=(y);i--)
22 #define mod 1000000007
23 using namespace std;
24 inline int read()
25 {
26     int x=0,f=1;char ch=getchar();
27     while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
28     while(ch>='0'&&ch<='9'){x=10*x+ch-'0';ch=getchar();}
29     return x*f;
30 }
31 ll n,tot,cnt=1,v[maxn],ls[maxn],rs[maxn],s[maxn],sum[2],ans[2];
32 ll ret=0;
33 struct rec{int x,y;}a[maxn],b[maxn];
34 void dfs(int x)
35 {
36    v[x]=read();
37     if(v[x]){s[x]=1;a[++tot].x=v[x];a[tot].y=tot;return;};
38     ls[x]=++cnt;dfs(ls[x]);
39     rs[x]=++cnt;dfs(rs[x]);
40     s[x]=s[ls[x]]+s[rs[x]];
41 }
42 void solve(int k,int l,int r)
43 {
44     int mid=l+s[ls[k]]-1,pl=l-1,pr=mid;
45     if(!s[ls[k]])return;
46     sum[0]=sum[1]=ans[0]=ans[1]=0;
47     for2(i,l,r)
48      {
49          int x=a[i].y<=mid?0:1;
50          sum[x]++;ans[x]+=sum[1-x];
51      }
52     ret+=min(ans[0],ans[1]);
53     for2(i,l,r)if(a[i].y<=mid)b[++pl]=a[i];else b[++pr]=a[i]; 
54     for2(i,l,r)a[i]=b[i];
55     solve(ls[k],l,mid);
56     solve(rs[k],mid+1,r);
57     pl=l,pr=mid+1;
58     for2(i,l,r)
59      if((a[pl].x<a[pr].x||pr>r)&&pl<=mid)b[i]=a[pl++];else b[i]=a[pr++];
60     for2(i,l,r)a[i]=b[i];
61 }
62 inline bool cmp(rec a,rec b)
63 {
64     return a.x<b.x;
65 }
66 int main()
67 {
68     freopen("input.txt","r",stdin);
69     freopen("output.txt","w",stdout);
70     n=read();
71     dfs(1);
72     //for1(i,4*n)cout<<ls[i]<<' '<<rs[i]<<' '<<s[i]<<endl;
73     sort(a+1,a+n+1,cmp);
74     solve(1,1,n);
75     printf("%lld\n",ret);
76     return 0;
77 }

View Code

神一样的题解，居然是用线段树启发式合并！

：

注意到对于一个非叶子节点，是否交换它的儿子对它之后的统计没有影响，那么只需要统计每个点左右儿子是否交换，并求出每个节点贡献的逆序对数Sum[i],求∑Sum[i]即可；

求Sum[i]的时候，每个点维护一个线段树表示这个点的子树内的权值情况(有无,权值1~n为下标)，可以先解决i的左右儿子；这时候只要考虑左右儿子之间对答案的贡献，若不交换左右儿子，贡献就是∑(i>j)(i属于左儿子，j属于右儿子)，否则相反；那么我们想到用启发式合并的思想，每次在线段树中插入一个元素x，并且统计答案(具体是∑(size[j]) | j为线段树的右边节点而且x属于线段树的左边节点)，那么时间复杂度是 O(Nlog^2N)

更好的方法：直接两颗线段树合并，并顺便统计答案即可(并且贪心考虑在这个节点是不是要交换左右儿子)；

时间复杂度的证明：

由于是动态节点，那么对于要合并的两棵树，复杂度正比与他们的公共节点数目；

又因为元素是1~n的排列，不会重复，那么对于线段树每一层的节点单独考虑经过次数，对于第i层，∑size的大小是n，对于每一个节点经过次数不会超过 size大小，由于线段树有LogN层，那么总的节点经过次数是NLogN,又因为线段树节点的Update操作均是常数时间完成的，那么总的时间复杂度是O(NlogN)

太神了！原来逆序对还能这么求！orz！

代码：

 1 #include<cstdio>
 2 #include<cstdlib>
 3 #include<cmath>
 4 #include<cstring>
 5 #include<algorithm>
 6 #include<iostream>
 7 #include<vector>
 8 #include<map>
 9 #include<set>
10 #include<queue>
11 #include<string>
12 #define inf 1000000000
13 #define maxn 250000
14 #define maxm 500+100
15 #define eps 1e-10
16 #define ll long long
17 #define pa pair<int,int>
18 #define for0(i,n) for(int i=0;i<=(n);i++)
19 #define for1(i,n) for(int i=1;i<=(n);i++)
20 #define for2(i,x,y) for(int i=(x);i<=(y);i++)
21 #define for3(i,x,y) for(int i=(x);i>=(y);i--)
22 #define mod 1000000007
23 using namespace std;
24 inline int read()
25 {
26     int x=0,f=1;char ch=getchar();
27     while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
28     while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
29     return x*f;
30 }
31 struct{ll sum,ls,rs;}t[25*maxn];
32 ll n,ret=0,tot,ans[2];
33 int build(int l,int r,int x)
34 {
35     int k=++tot,mid=(l+r)>>1;
36     t[k].sum=1;
37     if(l==r)return k;
38     if(x<=mid)t[k].ls=build(l,mid,x);else t[k].rs=build(mid+1,r,x);
39     return k;
40 }
41 int merge(int l,int r)
42 {
43     if(l*r==0)return l+r;
44     ans[0]+=t[t[l].ls].sum*t[t[r].rs].sum;
45     ans[1]+=t[t[l].rs].sum*t[t[r].ls].sum;
46     t[l].sum+=t[r].sum;
47     t[l].ls=merge(t[l].ls,t[r].ls);
48     t[l].rs=merge(t[l].rs,t[r].rs);
49     return l;
50 }
51 int work()
52 {
53     int x=read();
54     if(x)return build(1,n,x);
55     int l=work(),r=work();
56     ans[0]=ans[1]=0;
57     if(t[l].sum<t[r].sum)swap(l,r);
58     x=merge(l,r);
59     ret+=min(ans[0],ans[1]);
60     return x;
61 }
62 int main()
63 {
64     freopen("input.txt","r",stdin);
65     freopen("output.txt","w",stdout);
66     n=read();
67     work();
68     printf("%lld\n",ret);
69     return 0;
70 }