2017 Multi-University Training Contest - Team 1 1003(hdu6035Colorful Tree) 树 dfs 1008(6040 Hints)

1003(hdu6035Colorful Tree)题目：http://acm.hdu.edu.cn/showproblem.php?pid=6035.

题意：树上每个点有自己的颜色，树上每条路径的贡献值是这条路径上的点的不同颜色个数，求所有路径的贡献总和

求所有路径上不同颜色的个数和，其实也就是求所有颜色被多少条路径经过，这个并不好求，可以转化为求所有颜色不被哪些路径经过，最后用总路径条数减一下就可以了

求的方法很巧妙，考虑一颗根的颜色为c1,节点号为n1的子树，这颗子树上的节点和别的节点都不可能有不经过根n1的路径，在把这颗子树上所有根的颜色为c1的子树去掉，剩下的节点任意两两之间（不包括根节点n1）都会有一条不经过c1的路径，按照这个思想去求，可以dfs前缀实现，也可以全部处理，遍历实现

标程是先处理，后遍历，主要是二分那块比较难懂，其实就是去掉子树上所有根的颜色为c1的子树。

#include<bits/stdc++.h>
using namespace std;
const int maxn=200005;
long long fun(long long x)
{
return x*(x-1)>>1;
}
vector<int>w[maxn],c[maxn];
int num[maxn],n,l[maxn],r[maxn],fa[maxn],cnt=0;
long long ans;
int dfs(int x,int f)
{
num[x]=1,fa[x]=f;
l[x]=++cnt;
for(int i=0;i<w[x].size();i++)
{
int now=w[x][i];
if(now==f)
continue;
dfs(now,x);
num[x]+=num[now];
}
r[x]=cnt;
}
int cmp(int u,int v)
{
return l[u]<l[v];
}
int main()
{
int tcase=0,i,j,ii,u,v;
while(cin>>n)
{
ans=cnt=0;
tcase++;
memset(num,0,sizeof(num));
for(i=1;i<=n;i++)
scanf("%d",&u),c[u].push_back(i);
for(i=1;i<n;i++)
{
scanf("%d %d",&u,&v);
w[u].push_back(v);
w[v].push_back(u);
}
ans=n*fun(n);
w[0].push_back(1);
dfs(0,0);
for(i=1;i<=n;i++)
{
if(c[i].size()==0)
{
ans-=fun(n);
continue;
}
c[i].push_back(0);
sort(c[i].begin(),c[i].end(),cmp);
for(j=0;j<c[i].size();j++)
{
int x=c[i][j];
for(ii=0;ii<w[x].size();ii++)
{
int y=w[x][ii];
if(y==fa[x])
continue;
l[n+1]=l[y];
int now=num[y];
while(1)
{
vector<int>::iterator it=lower_bound(c[i].begin(),c[i].end(),n+1,cmp);
if(it==c[i].end()||l[*it]>r[y])
break;
l[n+1]=r[*it]+1;
now-=num[*it];
}
ans-=fun(now);
}
}
}
for(i=0;i<=n;i++)
w[i].clear(),c[i].clear();
printf("Case #%d: %lld\n",tcase,ans);
}
}

看了别人前缀的方式求的很巧妙

#include<bits/stdc++.h>
using namespace std;
const int maxn=200005;
long long fun(long long x)
{
return x*(x-1)>>1;
}
vector<int>w[maxn];
int num[maxn],n,c[maxn],sum[maxn];
long long ans;
int dfs(int x,int fa)
{
num[x]=1;
int pre=sum[c[x]],sum_now=0;
for(int i=0;i<w[x].size();i++)
{
int now=w[x][i];
if(now==fa)
continue;
dfs(now,x);
int temp=sum[c[x]]-pre;
pre=sum[c[x]];
ans-=fun(num[now]-temp);
num[x]+=num[now];
sum_now+=temp;
}
sum[c[x]]+=num[x]-sum_now;
}
int main()
{
int tcase=0,i,u,v;
while(cin>>n)
{
ans=0;
tcase++;
memset(num,0,sizeof(num));
memset(sum,0,sizeof(sum));
for(i=1;i<=n;i++)
scanf("%d",&c[i]);
for(i=1;i<n;i++)
{
scanf("%d %d",&u,&v);
w[u].push_back(v);
w[v].push_back(u);
}
ans=n*fun(n);
dfs(1,0);
for(i=1;i<=n;i++)
{
ans-=fun(n-sum[i]);
}
for(i=0;i<=n;i++)
w[i].clear();
printf("Case #%d: %lld\n",tcase,ans);
}
}

1008(hdu6040  Hints of sd0061)题目：http://acm.hdu.edu.cn/showproblem.php?pid=6040

题意：根据已知函数构造序列，个数很大，给m个查询，查询这段序列里第k小的元素

直接做肯定会t，用了一个库函数nth_element()

STL中的nth_element()方法的使用 通过调用nth_element(start, start+n, end) 方法可以使第n大元素处于第n位置（从0开始,其位置是下标为 n的元素），并且比这个元素小的元素都排在这个元素之前，比这个元素大的元素都排在这个元素之后，但不能保证他们是有序的。参考自

但直接用库函数也是会t的，有一种快排的思想，先找查询里k较大的，这样前k小个元素就可以都放在序列左边了，下次只需从这一部分找更小的即可。

#include<bits/stdc++.h>
using namespace std;
unsigned x,y,z,a[10000050],ans[200];;
unsigned rng61() {
unsigned t;
x ^= x << 16;
x ^= x >> 5;
x ^= x << 1;
t = x;
x = y;
y = z;
z = t ^ x ^ y;
return z;
}
struct node
{
int index,b;
}num[200];
int cmp(node u,node v)
{
return u.b>v.b;
}
int main()
{
int tcase=1,n,m,i;
while(cin>>n>>m>>x>>y>>z)
{
for(i=0;i<n;i++)
a[i]=rng61();
num[0].b=n-1;
for(i=1;i<=m;i++)
scanf("%d",&num[i].b),num[i].index=i;
sort(num+1,num+m+1,cmp);
for(i=1;i<=m;i++)
{
if(num[i].b==num[i-1].b&&i!=1)
ans[num[i].index]=ans[num[i-1].index];
else
{
nth_element(a,a+num[i].b,a+num[i-1].b+1);
ans[num[i].index]=a[num[i].b];
}
}
printf("Case #%d:",tcase++);
for(i=1;i<=m;i++)
{
cout<<" "<<ans[i];
}
cout<<endl;
}
return 0;
}