CF786B Legacy && 线段树优化连边

线段树优化连边

要求点 \(x\) 向区间 \([L, R]\) 连边， 一次的复杂度上限为 \(O(n)\)

然后弄成线段树的结构



先父子连边边权为 \(0\)

这样连边就只需要连父亲就可以等效于连了区间内每个点

空间复杂度为线段树大小， 一次区间连边时间复杂度为 \(O(\log n)\)

这是连入边， 连出边的话反向建线段树内边即可

CF786B Legacy

默认情况下他不能用这把枪开启任何传送门。在网络上有q个售卖这些传送枪的使用方案。每一次你想要实施这个方案时你都可以购买它，但是每次购买后只能使用一次。每个方案的购买次数都是无限的。

网络上一共有三种方案可供购买： 1.开启一扇从星球v到星球u的传送门； 2.开启一扇从星球v到标号在[l,r]区间范围内任何一个星球的传送门。(即这扇传送门可以从一个星球出发通往多个星球) 3.开启一扇从标号在[l,r]区间范围内任何一个星球到星球v的传送门。(即这扇传送门可以从多个星球出发到达同一个星球)

Rick并不知道Morty在哪儿，但是Unity将要通知他Morty的具体位置，并且他想要赶快找到通往所有星球的道路各一条并立刻出发。因此对于每一个星球(包括地球本身)他想要知道从地球到那个星球所需的最小钱数。

Solution

线段树优化连边即可

Code

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define LL long long
#define REP(i, x, y) for(LL i = (x);i <= (y);i++)
using namespace std;
LL RD(){
    LL out = 0,flag = 1;char c = getchar();
    while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
    while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
    return flag * out;
    }
const LL maxn = 100019 << 2, inf = 0xfffffffffffffff;
LL head[maxn],nume = 1;
struct Node{
    LL v,dis,nxt;
    }E[maxn << 3];
void add(LL u,LL v,LL dis){
    E[++nume].nxt = head[u];
    E[nume].v = v;
    E[nume].dis = dis;
    head[u] = nume;
    }
LL num, nr, s;
#define lid (id << 1)
#define rid (id << 1) | 1
LL tot;
struct seg_tree{
	LL l, r;
	LL Index[2];
	}tree[maxn << 2];
void build(LL id, LL l, LL r){
	tree[id].l = l, tree[id].r = r;
	if(l == r){
		tree[id].Index[0] = tree[id].Index[1] = l;
		return ;
		}
	tree[id].Index[0] = ++tot;//入边
	tree[id].Index[1] = ++tot;//out
	LL mid = (l + r) >> 1;
	build(lid, l, mid), build(rid, mid + 1, r);
	add(tree[id].Index[0], tree[lid].Index[0], 0);
	add(tree[id].Index[0], tree[rid].Index[0], 0);
	add(tree[lid].Index[1], tree[id].Index[1], 0);
	add(tree[rid].Index[1], tree[id].Index[1], 0);
	}
void IG(LL id, LL u, LL dis, LL l, LL r, LL o){//0 --> in, 1 --> out
	if(tree[id].l == l && tree[id].r == r){
		if(o == 2)add(u, tree[id].Index[0], dis);
		else add(tree[id].Index[1], u, dis);
		return ;
		}
	LL mid = (tree[id].l + tree[id].r) >> 1;
	if(mid < l)IG(rid, u, dis, l, r, o);
	else if(mid >= r)IG(lid, u, dis, l, r, o);
	else IG(lid, u, dis, l, mid, o), IG(rid, u, dis, mid + 1, r, o);
	}
void init(){
	num = RD(), nr = RD(), s = RD();
	tot = num;
	build(1, 1, num);
	REP(i, 1, nr){
		LL cmd = RD(), u = RD();
		if(cmd == 1){
			LL v = RD(), dis = RD();
			add(u, v, dis);
			}
		else{
			LL l = RD(), r = RD(), dis = RD();
			IG(1, u, dis, l, r, cmd);
			}
		}
	}
LL d[maxn];
bool vis[maxn];
void Djs(LL s){
	REP(i, 1, tot)d[i] = inf;
	priority_queue<pair<LL, LL> >Q;
	d[s] = 0;
	Q.push(make_pair(-d[s], s));
	while(!Q.empty()){
		LL u = Q.top().second;Q.pop();
		if(vis[u])continue;
		vis[u] = 1;
		for(LL i = head[u];i;i = E[i].nxt){
			LL v = E[i].v, dis = E[i].dis;
			if(d[u] + dis < d[v]){
				d[v] = d[u] + dis;
				Q.push(make_pair(-d[v], v));
				}
			}
		}
	}
void solve(){
	Djs(s);
	REP(i, 1, num){
		if(d[i] == inf)printf("-1 ");
		else printf("%lld ", d[i]);
		}
	puts("");
	}
int main(){
	init();
	solve();
	return 0;
	}