HDU 5957 环套树+线段树维护bfs序

题意:

n个点n条边的连通图,边长度都为1,没有重边自环,两种操作:

1.把与x距离小于等于k的所有点的权值增加d  (k<=2)

2.问离x距离小于等于k的所有点的权值和 (k<=2)

 

思路:

首先这是个环套树,找到环后从环上的每个点开始bfs,处理出每个点向子树走k步的bfs序区间,一层层维护就好了。

分类讨论比较麻烦。

 

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=100005;
ll lazy[4*N],sum[4*N];
int n;
void init()
{
    memset(lazy,0,sizeof(lazy));
    memset(sum,0,sizeof(sum));
}
void up(int x)
{
	sum[x]=sum[x*2]+sum[x*2+1];
}
void down(int x,int l,int r)
{
	if (lazy[x])
	{
		int mid=(l+r)/2;
		sum[x*2]+=(mid-l+1)*lazy[x];
		sum[x*2+1]+=(r-mid)*lazy[x];
		lazy[x*2]+=lazy[x];
		lazy[x*2+1]+=lazy[x];
		lazy[x]=0;
	}
}
void add(int i,int l,int r,int x,int y,int w)
{
	if (x<=l&&r<=y)
	{
		sum[i]+=w*(r-l+1);
		lazy[i]+=w;
		return;
	}
	down(i,l,r);
	int mid=(l+r)/2;
	if (x<=mid) add(i*2,l,mid,x,y,w);
	if (y>mid) add(i*2+1,mid+1,r,x,y,w);
	up(i);
}
ll get(int i,int l,int r,int x,int y)
{
	if (x<=l&&r<=y) return sum[i];
	down(i,l,r);
	int mid=(l+r)/2;
	ll ret=0;
	if (x<=mid) ret+=get(i*2,l,mid,x,y);
	if (y>mid) ret+=get(i*2+1,mid+1,r,x,y);
	return ret;
}

void ad(int l,int r,int w)
{
	if (l>r) return;
	add(1,1,n,l,r,w);
}
ll gt(int l,int r)
{
	if (l>r) return 0;
	return get(1,1,n,l,r);
}

bool vis[N],on[N];
int l[N],r[N];
vector<int>link[N];
int dfs1(int u,int fa)
{
	vis[u]=1;
	for (int i=0;i<link[u].size();i++)
	{
		int v=link[u][i];
		if (v==fa) continue;
		l[v]=u;
		if (vis[v]) return v;
		int tmp=dfs1(v,u);
		if (tmp) return tmp;
	}
	return 0;
}
int tot;
int q[N],bl[N][3],br[N][3],fa[N];
void bfs(int u)
{
	vis[u]=1;
	q[++tot]=u;
	bl[u][0]=tot; bl[u][1]=bl[u][2]=N;
	br[u][0]=tot; br[u][1]=br[u][2]=0;
	int head=tot;
	while(head<=tot)
	{
		int u=q[head]; head++;
		for (int i=0;i<link[u].size();i++)
		{
			int v=link[u][i];
			if (vis[v]||on[v]) continue;
			q[++tot]=v;
			bl[v][0]=tot; bl[v][1]=bl[v][2]=N;
			br[v][0]=tot; br[v][1]=br[v][2]=0;
			fa[v]=u;
			vis[v]=1;
		}
	}
}

void look(int n)
{
	for (int i=1;i<=n;i++)
	{
		printf("%d %lld\n",i,get(1,1,n,bl[i][0],br[i][0]));
	}
}
char s[10];
int main()
{
	int t; scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for (int i=1;i<=n;i++)
		{
			int x,y; scanf("%d%d",&x,&y);
			link[x].push_back(y);
			link[y].push_back(x);
		}

		for (int i=1;i<=n;i++) vis[i]=0,on[i]=0;
		int root=dfs1(1,1);
		r[l[root]]=root; on[root]=1;
        for (int i=l[root];i!=root;i=l[i])  r[l[i]]=i,on[i]=1;

        tot=0;
        for (int i=1;i<=n;i++) vis[i]=0;
        bfs(root);
		for (int i=l[root];i!=root;i=l[i]) bfs(i);
        for (int k=1;k<=2;k++)
			for (int i=tot;i>=1;i--)
			{
				int v=q[i];
				if (on[v]) continue;
				int u=fa[v];
				bl[u][k]=min(bl[u][k],bl[v][k-1]);
				br[u][k]=max(br[u][k],br[v][k-1]);
			}

		init();
        int m; scanf("%d",&m);
		while(m--)
		{
			//look(n);
			scanf("%s",s);
			if (s[0]=='M')
			{
				int u,k,w; scanf("%d%d%d",&u,&k,&w);
				if (k==0) ad(bl[u][0],br[u][0],w);
				if (k==1)
				{
					ad(bl[u][0],br[u][0],w);
					ad(bl[u][1],br[u][1],w);//
					if (on[u])
					{
						int lv=l[u],rv=r[u];
						ad(bl[lv][0],br[lv][0],w);
						ad(bl[rv][0],br[rv][0],w);
					}
					else
					{
						int v=fa[u];
						ad(bl[v][0],br[v][0],w);
					}
				}
				if (k==2)
				{
					ad(bl[u][0],br[u][0],w);
					ad(bl[u][1],br[u][1],w);
					ad(bl[u][2],br[u][2],w);
					if (on[u])
					{
						int lv=l[u];
						ad(bl[lv][0],br[lv][0],w);
						ad(bl[lv][1],br[lv][1],w);
						int rv=r[u];
						ad(bl[rv][0],br[rv][0],w);
						ad(bl[rv][1],br[rv][1],w);
						lv=l[lv];
						if (lv!=rv)
							ad(bl[lv][0],br[lv][0],w);
						else lv=r[lv];
						rv=r[rv];
						if (rv!=lv)
							ad(bl[rv][0],br[rv][0],w);
					}
					else
					{
						int v=fa[u];
						ad(bl[v][0],br[v][0],w);
						ad(bl[v][1],br[v][1],w);
						ad(bl[u][0],br[u][0],-w);
						if (on[v])
						{
							int lv=l[v],rv=r[v];
							ad(bl[lv][0],br[lv][0],w);
							ad(bl[rv][0],br[rv][0],w);
						}
						else
						{
							v=fa[v];
							ad(bl[v][0],br[v][0],w);
						}
					}
				}
			}
			if (s[0]=='Q')
			{
				int u,k,w; scanf("%d%d",&u,&k);
				ll ret=0;
				if (k==0) ret+=gt(bl[u][0],br[u][0]);
				if (k==1)
				{
					ret+=gt(bl[u][0],br[u][0]);
					ret+=gt(bl[u][1],br[u][1]);
					if (on[u])
					{
						int lv=l[u],rv=r[u];
						ret+=gt(bl[lv][0],br[lv][0]);
						ret+=gt(bl[rv][0],br[rv][0]);
					}
					else
					{
						int v=fa[u];
						ret+=gt(bl[v][0],br[v][0]);
					}
				}
				if (k==2)
				{
					ret+=gt(bl[u][0],br[u][0]);
					ret+=gt(bl[u][1],br[u][1]);
					ret+=gt(bl[u][2],br[u][2]);
					if (on[u])
					{
						int lv=l[u];
						ret+=gt(bl[lv][0],br[lv][0]);
						ret+=gt(bl[lv][1],br[lv][1]);
						int rv=r[u];
						ret+=gt(bl[rv][0],br[rv][0]);
						ret+=gt(bl[rv][1],br[rv][1]);
						lv=l[lv];
						if (lv!=rv)
							ret+=gt(bl[lv][0],br[lv][0]);
						else lv=r[lv];
						rv=r[rv];
						if (rv!=lv)
							ret+=gt(bl[rv][0],br[rv][0]);
					}
					else
					{
						int v=fa[u];
						ret+=gt(bl[v][0],br[v][0]);
						ret+=gt(bl[v][1],br[v][1]);
						ret-=gt(bl[u][0],br[u][0]);
						if (on[v])
						{
							int lv=l[v],rv=r[v];
							ret+=gt(bl[lv][0],br[lv][0]);
							ret+=gt(bl[rv][0],br[rv][0]);
						}
						else
						{
							v=fa[v];
							ret+=gt(bl[v][0],br[v][0]);
						}
					}
				}
				printf("%lld\n",ret);
			}

		}

		for (int i=1;i<=n;i++) link[i].clear();
	}
}
/*
1
8
1 2
2 3
3 4
1 4
2 5
3 6
5 7
5 8
12
MODIFY 8 1 5
MODIFY 8 2 2
QUERY 5 0
QUERY 5 1
QUERY 5 2
MODIFY 7 2 2
QUERY 7 2
MODIFY 3 1 5
MODIFY 2 2 2
QUERY 6 1
MODIFY 4 1 -2
QUERY 2 2
*/

 

HDU5956 The Elder 下凸壳的维护

题意:

一棵树,1为根。每个点只能走向祖先,时间为距离的平方,另外走到祖先后会停留P单位时间。求每个点到达根的最小时间的最大值。

 

思路:

显然dp方程为:f[i]=(d[i]-d[j])^2+P+f[j]  ( j 是 i 的祖先)

转化成向量点积形式:f[i]=d[i]^2+P+(1 , 2*d[i] ) * ( f[j]+d[j]^2 , -d[j] )

注意到深度越大,向量(1 , 2*d[i] )会逆时针旋转

于是维护点集i的所有祖先的  ( f[j]+d[j]^2 , -d[j] ) 的下凸壳,就能求出f[i]的最小值

注意到向量( f[j]+d[j]^2 , -d[j] )只会添加在下凸壳右边,于是只要用个队列来保存就可以了

查询的时候只要一直扔掉左边的点,找到最大值为止,然后退出当前dfs的时候加回来就可以了

如果一个个保存删掉的点,再一个个加回来的话,在菊花图的情况下复杂度就会变成O(n^2),事实上目前网上的题解都是这么做的,估计出题人也没意识到复杂度的问题,因为这看起来很像O(n)。

我的做法是每次dfs记录当前队列的左端点,和右端点,操作完后,事实上只是替换了数组里的tail位置的元素,把head和tail还有这个元素事先保存下来,最后恢复head,tail和这个元素就可以了,这样复杂度就是完美的O(n)了。

也不知道这种做法叫什么,毕竟自己乱想出来的,就叫回溯队列好了233

后来一想这个做法还是n方。。。因为每次head和tail的删除操作都可能是O(n)的,所以要二分查找head和tail分别应该删到哪,这样算法复杂度就是O(nlogn)了

这里如果不用斜率,而把两边的dx都乘到对面去的话是有问题的,因为f[j]+d[j]^2的规模是1e14,2*d[i]的规模是1e7,乘起来理论上会爆,然而数据好像还是没卡掉这种做法

 

代码1:O(n^2)做法

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=100005;
struct P
{
	ll x,y;
	ll operator*(const P &b)const
	{
		return x*b.x+y*b.y;
	}
}stk[N];
int n,p;
int head,tail;
vector<P>link[N];
ll f[N],d[N];
long double slope(P a,P b)
{
	long double tmp=1.0;
	return tmp*(b.y-a.y)/(b.x-a.x);
}
void dfs(int u,int fa,int deep)
{
	int phead=head,ptail=tail;
	d[u]=deep;
	if (u==1) f[u]=-p;
	else
	{
		P tmp={1,2*d[u]};
		while(tail-head+1>=2&&stk[head]*tmp>=stk[head+1]*tmp) head++;
		f[u]=d[u]*d[u]+p+stk[head]*tmp;
	}
	P tmp={f[u]+d[u]*d[u],-d[u]};
	while(tail-head+1>=2&&
		slope(stk[tail-1],stk[tail])>=slope(stk[tail],tmp)) tail--;
	P mem=stk[tail+1];
	stk[++tail]=tmp;

	for (int i=0;i<link[u].size();i++)
	{
		int v=link[u][i].x;
		if (v==fa) continue;
		dfs(v,u,deep+link[u][i].y);
	}
	tail--;
	stk[tail+1]=mem;
	head=phead; tail=ptail;
}
int main()
{
	int t; scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&p);
		for (int i=1;i<n;i++)
		{
			ll x,y,z;
			scanf("%d%d%lld",&x,&y,&z);
			if (z<0) n/=0;
			link[x].push_back({y,z});
		}
		head=1; tail=0;
		dfs(1,1,0);
		ll ans=0;
		for (int i=1;i<=n;i++) ans=max(ans,f[i]);
		printf("%lld\n",ans);

		for (int i=1;i<=n;i++) link[i].clear();
	}
}

 

代码2:O(nlogn)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=100005;
struct P
{
    ll x,y;
    ll operator*(const P &b)const
    {
        return x*b.x+y*b.y;
    }
}stk[N];
int n,p;
int head,tail;
vector<P>link[N];
ll f[N],d[N];
long double slope(P a,P b)
{
    long double tmp=1.0;
    return tmp*(b.y-a.y)/(b.x-a.x);
}
int gethead(P v)
{
	int l=head,r=tail;
	while(l<r)
	{
		int mid=(l+r)/2;
		if (stk[mid]*v>=stk[mid+1]*v) l=mid+1;
		else r=mid;
	}
	return l;
}
int gettail(P v)
{
	int l=head,r=tail;
	while(l<r)
	{
		int mid=(l+r)/2;
		if (slope(stk[mid],stk[mid+1])<slope(stk[mid+1],v)) l=mid+1;
		else r=mid;
	}
	return l;
}
void dfs(int u,int fa,int deep)
{
    int phead=head,ptail=tail;
    d[u]=deep;
    if (u==1) f[u]=-p;
    else
    {
        P tmp={1,2*d[u]};
        head=gethead(tmp);

        //while(tail-head+1>=2&&stk[head]*tmp>=stk[head+1]*tmp) head++;
        f[u]=d[u]*d[u]+p+stk[head]*tmp;
    }
    P tmp={f[u]+d[u]*d[u],-d[u]};
    tail=gettail(tmp);
//    while(tail-head+1>=2&&
//        slope(stk[tail-1],stk[tail])>=slope(stk[tail],tmp)) tail--;
    P mem=stk[tail+1];
    stk[++tail]=tmp;

    for (int i=0;i<link[u].size();i++)
    {
        int v=link[u][i].x;
        if (v==fa) continue;
        dfs(v,u,deep+link[u][i].y);
    }
    tail--;
    stk[tail+1]=mem;
    head=phead; tail=ptail;
}
int main()
{
    int t; scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&p);
        for (int i=1;i<n;i++)
        {
            ll x,y,z;
            scanf("%d%d%lld",&x,&y,&z);
            link[x].push_back({y,z});
        }
        head=1; tail=0;
        dfs(1,1,0);
        ll ans=0;
        for (int i=1;i<=n;i++) ans=max(ans,f[i]);
        printf("%lld\n",ans);

        for (int i=1;i<=n;i++) link[i].clear();
    }
}

hdu3043Number game(dp+dfs)

题意:给你所有1-n的波浪型排列,输出按字典序将这些序列排序后第k小的数列。

思路:可以先预处理出第i个位置是j的上波浪方案数和下波浪方案数。对于每一位,从小到大枚举j,如果当前的总方案数刚好大于等于k,那么答案数列中这个位置一定是j,如此dfs找下去。

因为输入数据有很多的t,一直WA在这个地方,测数据时也发现数据不对劲,问学长要了数据才发现这个坑。

#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<functional>
using namespace std;
const int N=25;
unsigned long long m,fu[N][N],fd[N][N];
int i,j,k,t,n;
int a[N];
void dfs(int d,long long k,int pre,int tp)
{
    if (d==0) return ;
    long long sum=0;
    int i;
    if (tp==-1)
    {
        for (i=1;i<pre;i++)
        {
            if (sum+fu[d][i]>=k) break;
            sum+=fu[d][i];
        }
    }
    else
    {
        for (i=pre;i<=d;i++)
        {
            if (sum+fd[d][i]>=k) break;
            sum+=fd[d][i];
        }
    }
    a[d]=i;
    dfs(d-1,k-sum,i,-tp);
}
int main()
{
    fd[1][1]=fu[1][1]=1;
    for (i=2;i<=20;i++)
    {
        for (j=1;j<=i;j++)
        {
            for (k=j;k<=i-1;k++) fu[i][j]+=fd[i-1][k];
            for (k=1;k<=j-1;k++) fd[i][j]+=fu[i-1][k];
        }
    }
    while(~scanf("%d",&t))
    	while(t--)
    {
    	scanf("%d%lld",&n,&m);
        if (n>250) n/=0;
        long long sum=0;
        for (i=1;i<=n;i++)
        {
            if (sum+fd[n][i]>=m)
            {
                a[n]=i;
                dfs(n-1,m-sum,i,-1);
                break;
            }
            sum+=fd[n][i];
            if (sum+fu[n][i]>=m)
            {
                a[n]=i;
                dfs(n-1,m-sum,i,1);
                break;
            }
            sum+=fu[n][i];
        }
        for (i=2;i<=n;i++)
            for (j=1;j<i;j++)
                if (a[i]<=a[j]) a[j]++;

        for (i=n;i>1;i--) printf("%d ",a[i]);
        printf("%d\n",a[1]);
    }
}