C++——最短路&&线段树 例题——Board

Board

题目背景

SOURCE：NOIP2016-RZZ-2 T3

题目描述

给出这样一棵“二叉树”：

• 每个节点有左右两个儿子，并如下定义每个节点的高度：假设父亲节点的高度为 h ，那么他的两个儿子的节点的高度都是 h + 1 ，相同高度的所有节点称作一层。
• 每个节点的左儿子的子树都在右儿子的子树的左边，每一层相邻的两个节点之间有一条边。

下面是一个例子：

    

每一条图上的路径用一个字符串表示，字符串中的每一个字符表示一个移动。字符仅包含如下五种：

• 1：表示移动到当前节点的左儿子
• 2：表示移动到当前节点的右儿子
• U：表示移动到当前节点的父亲节点
• L：表示移动到当前节点同层的左边的节点（保证当前节点在这一层中不是最左边的节点）
• R：表示移动到当前节点同层的右边的节点（保证当前节点在这一层中不是最右边的节点）

用一条路径来表示这条路径的终点，例如路径：221LU 就表示上图中的节点 A 。

给出两条路径，你的任务是求出着两条路径的终点之间的最短路。

输入格式

输入两行，每行一个字符串，分别表示两条路径。

输出格式

输出一行一个整数，表示能得到的串的总数。

样例数据 1

输入

221LU 
12L2

输出

3

备注

【数据规模与约定】
用 D 表示所有经过的节点中，深度最大的节点的深度；S 表示输入字符串的最大长度。
对于 10% 的数据，D≤10。
对于 30% 的数据，D≤50。
对于 50% 的数据，D≤1000。
对于 70% 的数据，D≤20000。
对于 100% 的数据，D≤100000；S≤100000。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
struct node{
	int lazy;
	int summary;
	int length;
}trans[270000];
int string_s[100003],string_t[100003],string_s_n,string_t_n;
void put(int x)
{
    int num=0;
	char c[12];
	do
	{
		c[++num]=(x%10)+48;
		x/=10;
	}while(x);
    while(num) putchar(c[num--]);
    putchar('\n');
}
void build_a_tree(int left,int right,int now)
{
	trans[now].length=right-left+1;
	trans[now].lazy=trans[now].summary=0;
	if(left==right) return;
	int middle=(left+right)>>1;
	build_a_tree(left,middle,now<<1);
	build_a_tree(middle+1,right,now<<1|1);
}
void add_lazy(int now,int lazy)
{
	trans[now].lazy=lazy;
	trans[now].summary=(lazy-1)*trans[now].length;
}
void push_down(int now)
{
	if(trans[now].lazy)
	{
		add_lazy(now<<1,trans[now].lazy);
		add_lazy(now<<1|1,trans[now].lazy);
		trans[now].lazy=0;
	}
}
void update(int now)
{
	trans[now].summary=trans[now<<1].summary+trans[now<<1|1].summary;
}
void modify(int left,int right,int now,int x,int y,int z)
{
	if(right<x||y<left) return;
	if(x<=left&&right<=y) return add_lazy(now,z);
	int middle=(left+right)>>1;
	push_down(now);
	modify(left,middle,now<<1,x,y,z);
	modify(middle+1,right,now<<1|1,x,y,z);
	update(now);
}
int query_left(int left,int right,int now,int x)
{
	if(x<left) return 0;
	if(trans[now].summary==trans[now].length) return 0;
	if(left==right) return trans[now].summary==0 ? left : 0;
	int middle=(left+right)>>1;
	push_down(now);
	int ret=query_left(middle+1,right,now<<1|1,x);
	if(!ret) ret=query_left(left,middle,now<<1,x);
	return ret;
}
int query_right(int left,int right,int now,int x)
{
	if(x<left) return 0;
	if(trans[now].summary==0) return 0;
	if(left==right) return trans[now].summary==1 ? left : 0;
	int middle=(left+right)>>1;
	push_down(now);
	int ret=query_right(middle+1,right,now<<1|1,x);
	if(!ret) ret=query_right(left,middle,now<<1,x);
	return ret;
}
void tree_export(int left,int right,int now,int x,int *_string)
{
	if(left>x) return;
	if(left==right)
	{
		_string[left]=trans[now].summary;
		return;
	}
	int middle=(left+right)>>1;
	push_down(now);
	tree_export(left,middle,now<<1,x,_string);
	tree_export(middle+1,right,now<<1|1,x,_string);
}
void read(int *_string,int &string_n)
{
	char *character =new char[100003];
	scanf("%s",character+1);
	int char_length=strlen(character+1);
	build_a_tree(1,char_length,1);
	string_n=0;
	for(int i=1,j=char_length;i<=j;++i)
	{
		switch(character[i])
		{
			case '1':
				{
					++string_n;
					modify(1,char_length,1,string_n,string_n,1);
					break;
				}
			case '2':
				{
					++string_n;
					modify(1,char_length,1,string_n,string_n,2);
					break;
				}
			case 'U':
				{
					--string_n;
					break;
				}
			case 'L':
				{
					int position=query_right(1,char_length,1,string_n);
					modify(1,char_length,1,position+1,string_n,2);
					modify(1,char_length,1,position,position,1);
					break;
				}
			case 'R':
				{
					int position=query_left(1,char_length,1,string_n);
					modify(1,char_length,1,position+1,string_n,1);
					modify(1,char_length,1,position,position,2);
					break;
				}
		}
	}
	tree_export(1,char_length,1,string_n,_string);
	delete [] character;
}
int main()
{
	read(string_s,string_s_n);
	read(string_t,string_t_n);
	int _summary=abs(string_s_n-string_t_n);
	int _n=min(string_s_n,string_t_n);
	int distance=0;
	int answer=_n<<1;
	bool flag=1;
	for(int i=1;i<=_n;++i)
	{
		if(!flag)
		{
			distance<<=1;
			if(string_s[i]==0) ++distance;
			if(string_t[i]==1) ++distance;
		}
		if(string_s[i]!=string_t[i]&&flag)
		{
			flag=0;
			if(string_s[i]==1) swap(string_s,string_t);
		}
		if(distance>answer) break;
		answer=min(answer,distance+!flag+2*(_n-i));
	}
	put(_summary+answer);
	return 0;
}