HYSBZ - 2157树链剖分

最新推荐文章于 2022-05-04 21:17:07 发布
最新推荐文章于 2022-05-04 21:17:07 发布
阅读量159 收藏
点赞数
分类专栏： # 2019暑假集训 # 数据结构 # 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T_T233333333/article/details/98497181
版权

【题目描述】
HYSBZ - 2157树链剖分
在这里插入图片描述
【题目分析】
这道题给出的是边权而不是点权，但是我们分析这个树就会发现每个节点都只有一个父亲，也就是每条边的边权都可以存放在儿子节点上，然后在遍历路径的时候我们在从前往后遍历，但是注意最后一条链的链首不要算在内（因为我们只算边权，链首存储的值不在路径上）
接下来就是无穷无尽的代码了，我自己写的一直一直wa，我看了一天了也没有看出哪里有问题，借鉴大佬的代码：
【AC代码】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

const int maxn = 120000;
#define ll long long
#define ls now<<1
#define rs now<<1|1
inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { x = x * 10 + ch - 48; ch = getchar(); }
    return x * f;
}
struct node
{
    ll f, t, v;
}e[maxn << 1];
struct tree
{
    ll l, r, sum, maxx, minn, add, mul , num;
}tre[maxn << 2];
ll n, m, tot, cnt;
ll head[maxn], nxt[maxn << 1], used[maxn], dep[maxn], fa[maxn], sz[maxn], w1[maxn];
ll w2[maxn] , son[maxn] , top[maxn] , num[maxn];
inline void buildnode(ll a, ll b , ll c)
{
    tot++;
    e[tot].f = a;
    e[tot].t = b;
    e[tot].v = c;
    nxt[tot] = head[a];
    head[a] = tot;
}
inline void pushup(ll now)
{
    tre[now].sum = tre[ls].sum + tre[rs].sum;
    tre[now].maxx = max(tre[ls].maxx, tre[rs].maxx);
    tre[now].minn = min(tre[ls].minn, tre[rs].minn);
}
inline void build(ll now, ll l, ll r)
{
    tre[now].l = l;
    tre[now].r = r;
    tre[now].num = r - l + 1;
    if (l == r)
    {
        tre[now].sum = w2[l];
        tre[now].maxx = w2[l];
        tre[now].minn = w2[l];
        return;
    }
    ll mid = (l + r) >> 1;
    build(ls, l, mid);
    build(rs, mid + 1 , r);
    pushup(now);
}
inline void pushdown(ll now)
{
    if (tre[now].mul)
    {
        tre[ls].sum *= -1;
        tre[rs].sum *= -1;
        ll t = tre[ls].maxx;
        tre[ls].maxx = -tre[ls].minn;
        tre[ls].minn = -t;
        t = tre[rs].maxx;
        tre[rs].maxx = -tre[rs].minn;
        tre[rs].minn = -t;
    }
    tre[ls].mul = (tre[ls].mul + tre[now].mul) % 2;
    tre[rs].mul = (tre[rs].mul + tre[now].mul) % 2;
    tre[now].mul = 0;
}
inline void update1(ll now, ll x ,  ll p)
{
    if (tre[now].l == tre[now].r)
    {
        tre[now].sum = p;
        tre[now].maxx = p;
        tre[now].minn = p;
        return;
    }
    pushdown(now);
    ll mid = (tre[now].l + tre[now].r) >> 1;
    if (x <= mid) update1(ls, x, p);
    if (x > mid) update1(rs, x, p);
    pushup(now);
}
inline void update2(ll now, ll l, ll r)
{
    if (l <= tre[now].l && tre[now].r <= r)
    {
        tre[now].sum = -tre[now].sum;
        tre[now].mul = (tre[now].mul + 1) % 2;
        ll t = tre[now].maxx;
        tre[now].maxx = -tre[now].minn;
        tre[now].minn = -t;
        return;
    }
    pushdown(now);
    ll mid = (tre[now].l + tre[now].r) >> 1;
    if (l <= mid) update2(ls, l, r);
    if (r > mid) update2(rs, l, r);
    pushup(now);
}
inline void dfs1(ll x, ll fat)
{
    dep[x] = dep[fat] + 1;
    fa[x] = fat;
    sz[x] = 1;
    int k = -1;
    for (int i = head[x]; i; i = nxt[i])
    {
        int u = e[i].t;
        if (u == fa[x]) continue;
        w1[u] = e[i].v;
        dfs1(u, x);
        sz[x] += sz[u];
        if (sz[u] > k) k = sz[u], son[x] = u;
    }
}
inline void dfs2(ll x , ll topx)
{
    num[x] = ++cnt;
    w2[cnt] = w1[x];
    top[x] = topx;
    if (!son[x]) return;
    dfs2(son[x], topx);
    for (int i = head[x]; i; i = nxt[i])
    {
        int u = e[i].t;
        if (u == fa[x] || u == son[x]) continue;
        dfs2(u, u);
    }
}
inline int querys(ll now, ll l, ll r)
{
    if (l <= tre[now].l && tre[now].r <= r)
        return tre[now].sum;
    pushdown(now);
    ll mid = (tre[now].l + tre[now].r) >> 1, ans = 0;
    if (l <= mid) ans += querys(ls, l, r);
    if (r > mid) ans += querys(rs, l, r);
    return ans;
}
inline ll query_max(ll now, ll l , ll r)
{
    if (l <= tre[now].l &&tre[now].r <= r)
        return tre[now].maxx;
    pushdown(now);
    ll mid = (tre[now].l + tre[now].r) >> 1, ans = -1e9;
    if (l <= mid) ans = max(ans, query_max(ls, l, r));
    if (r > mid) ans = max(ans, query_max(rs, l, r));
    return ans;
}
inline ll query_min(ll now, ll l , ll r)
{
    if (l <= tre[now].l &&tre[now].r <= r)
        return tre[now].minn;
    pushdown(now);
    ll mid = (tre[now].l + tre[now].r) >> 1, ans = 1e9;
    if (l <= mid) ans = min(ans, query_min(ls, l, r));
    if (r > mid) ans = min(ans, query_min(rs, l, r));
    return ans;
}
inline ll qline(ll x, ll y)
{
    ll ans = 0;
    while (top[x] != top[y])
    {
        if (dep[top[x]] < dep[top[y]]) swap(x , y);
            ans += querys(1, num[top[x]], num[x]);
        x = fa[top[x]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    ans += querys(1, num[x] + 1, num[y]);
    return ans;
}
inline void cline(ll x, ll y)
{
    while (top[x] != top[y])
    {
        if (dep[top[x]] < dep[top[y]]) swap(x , y);
            update2(1, num[top[x]], num[x]);
        x = fa[top[x]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    update2(1, num[x] + 1, num[y]);
}
inline ll qpmax(ll x, ll y)
{
    ll ans = -1e9;
    while (top[x] != top[y])
    {
        if (dep[top[x]] < dep[top[y]]) swap(x , y);
            ans = max(ans, query_max(1, num[top[x]], num[x]));
        x = fa[top[x]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    ans = max(ans, query_max(1, num[x] + 1, num[y]));
    return ans;
}
inline ll qpmin(ll x, ll y)
{
    ll ans = 1e9;
    while (top[x] != top[y])
    {
        if (dep[top[x]] < dep[top[y]]) swap(x , y);
            ans = min(ans, query_min(1, num[top[x]], num[x]));
        x = fa[top[x]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    ans = min(ans, query_min(1, num[x] + 1, num[y]));
    return ans;
}
string s1 = "C", s2 = "N", s3 = "SUM", s4 = "MAX", s5 = "MIN";
int main()
{
    //freopen("1.in","r",stdin);
    n = read();
    for (int i = 1; i <= n - 1; i++)
    {
        int a, b, c;
        a = read(); b = read(); c = read();
        buildnode(a + 1, b + 1, c);
        buildnode(b + 1, a + 1, c);
    }
    dfs1(1 , 0);
    dfs2(1 , 1);
    build(1 , 1 , n);
    m = read();
    while (m--)
    {
        string s;
        int a, b, k;
        cin >> s >> a >> b;
        a += 1 , b += 1;
        if (s == s1)
        {
            a -= 1 , b -= 1;
            if (dep[e[a * 2 - 1].f] > dep[e[a * 2 - 1].t])
                k = e[a * 2 - 1].f;
            else k = e[a * 2 - 1].t;
            update1(1, num[k], b);
        }
        if (s == s2) cline(a, b);
        if (s == s3) printf("%lld\n", qline(a, b));
        if (s == s4) printf("%lld\n", qpmax(a, b));
        if (s == s5) printf("%lld\n", qpmin(a, b));
    }
    return 0;
}

我自己写的也贴上，方便日后检查

#include<cstdio>
#include<cstring>
#include<cmath>
#include<climits>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<vector>
#include<set>

using namespace std;

typedef long long ll;

const int MAXN=120005;
int fa[MAXN],A[MAXN],val[MAXN],pos[MAXN];
int siz[MAXN],son[MAXN],h[MAXN],top[MAXN];
int cnt=0,n,m;
int Sum[MAXN<<2],Max[MAXN<<2],Min[MAXN<<2],lazy[MAXN<<2];
struct node
{
	int u,v,w;
}e[MAXN<<1];
int head[MAXN<<1],nxt[MAXN<<1];
int tot=0;

void AddEdge(int u,int v,int w)
{
	tot++;
	e[tot].u=u; e[tot].v=v; e[tot].w=w;
	nxt[tot]=head[u]; head[u]=tot;
}

void dfs1(int u,int f)
{
    int i,v;
    siz[u]=1;
    son[u]=0;
    fa[u]=f;
    h[u]=h[f]+1;
    for(i=head[u];i;i=nxt[i])
	{
        v=e[i].v;
        if(v!=f)
		{
			val[v]=e[i].w;
            dfs1(v,u);
            siz[u]+=siz[v];
            if(siz[son[u]]<siz[v]) son[u]=v;
        }
    }
}
void dfs2(int u,int f,int k)
{
    int i,v;
    top[u]=k;
    pos[u]=++cnt;
    A[cnt]=val[u];
    if(!son[u]) return; 
    if(son[u]) dfs2(son[u],u,k);
    for(i=head[u];i;i=nxt[i])
	{
        v=e[i].v;
        if(v!=f&&v!=son[u]) dfs2(v,u,v);
    }
}

void pushup(int k)
{
	Sum[k]=Sum[k<<1]+Sum[k<<1|1];
	Max[k]=max(Max[k<<1],Max[k<<1|1]);
	Min[k]=min(Min[k<<1],Min[k<<1|1]);
}

void pushdown(int k)
{
	if(lazy[k])
	{
		Sum[k<<1]*=-1; Sum[k<<1|1]*=-1;
		swap(Max[k<<1],Min[k<<1]);
		Max[k<<1]*=-1; Min[k<<1]*=-1;
		swap(Max[k<<1|1],Min[k<<1|1]);
		Max[k<<1|1]*=-1; Min[k<<1|1]*=-1;
		lazy[k<<1]^=1; lazy[k<<1|1]^=1;
		lazy[k]=0;
	}
}

void build(int k,int l,int r)
{
	if(l==r)
	{
		Sum[k]=Max[k]=Min[k]=A[l];
		return;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	pushup(k);
}

void PointChange(int k,int l,int r,int x,int v)
{
	if(l==r && l==x)
	{
		Sum[k]=Max[k]=Min[k]=v;
		return;
	}
	pushdown(k);
	int mid=(l+r)>>1;
	if(x<=mid) PointChange(k<<1,l,mid,x,v);
	else PointChange(k<<1|1,mid+1,r,x,v);
	pushup(k);  
}

void IntervalChange(int k,int l,int r,int L,int R)
{
	if(l>=L && r<=R)
	{
		Sum[k]*=-1; swap(Max[k],Min[k]);
		Max[k]*=-1; Min[k]*=-1;
		lazy[k]^=1;
		return;
	}
	pushdown(k);
	int mid=(l+r)>>1;
	if(L<=mid) IntervalChange(k<<1,l,mid,L,R);
	if(R>mid) IntervalChange(k<<1|1,mid+1,r,L,R);
	pushup(k); 
}

int IntervalSum(int k,int l,int r,int L,int R)
{
    if(L<=l && r<=R)
    {
    	return Sum[k];
	}
    int mid=(l+r)/2;
    pushdown(k);
    int ret=0;
    if(L<=mid) ret+=IntervalSum(k<<1,l,mid,L,R);
    if(R>mid) ret+=IntervalSum(k<<1|1,mid+1,r,L,R);
    return ret;
}

int IntervalMax(int k,int l,int r,int L,int R)
{
    if(L<=l && r<=R)
    {
    	return Max[k];
	}
    int mid=(l+r)/2;
    pushdown(k);
    int ret=INT_MIN;
    if(L<=mid) ret=max(IntervalSum(k<<1,l,mid,L,R),ret);
    if(R>mid) ret=max(IntervalSum(k<<1|1,mid+1,r,L,R),ret);
    return ret;
}

int IntervalMin(int k,int l,int r,int L,int R)
{
    if(L<=l && r<=R)
    {
    	return Min[k];
	}
    int mid=(l+r)/2;
    pushdown(k);
    int ret=INT_MAX;
    if(L<=mid) ret=min(IntervalSum(k<<1,l,mid,L,R),ret);
    if(R>mid) ret=min(IntervalSum(k<<1|1,mid+1,r,L,R),ret);
    return ret;
}


int FindSum(int u,int v)
{
    int ans=0;
    while(top[u]!=top[v])
	{
		if(h[top[u]]<h[top[v]]) swap(u,v);
		ans+=IntervalSum(1,1,n,pos[top[u]],pos[u]);
		u=fa[top[u]];
    }
    if(h[u]<h[v]) swap(u,v);
    ans+=IntervalSum(1,1,n,pos[v]+1,pos[u]);
    return ans;
}

int FindMax(int u,int v)
{
    int ans=INT_MIN;
    while(top[u]!=top[v])
	{
		if(h[top[u]]<h[top[v]]) swap(u,v);
		ans=max(IntervalMax(1,1,n,pos[top[u]],pos[u]),ans);
		u=fa[top[u]];
    }
    if(h[u]<h[v]) swap(u,v);
    ans=max(IntervalMax(1,1,n,pos[v]+1,pos[u]),ans);
    return ans;
}

int FindMin(int u,int v)
{
    int ans=INT_MAX;
    while(top[u]!=top[v])
	{
		if(h[top[u]]<h[top[v]]) swap(u,v);
		ans=min(IntervalMin(1,1,n,pos[top[u]],pos[u]),ans);
		u=fa[top[u]];
    }
    if(h[u]<h[v]) swap(u,v);
    ans=min(IntervalMin(1,1,n,pos[v]+1,pos[u]),ans);
    return ans;
}

void update(int u,int v)
{
    while(top[u]!=top[v])
	{
		if(h[top[u]]<h[top[v]]) swap(u,v);
		IntervalChange(1,1,n,pos[top[u]],pos[u]);
		u=fa[top[u]];
    }
    if(h[u]<h[v]) swap(u,v);
   	IntervalChange(1,1,n,pos[v]+1,pos[u]);
}



int main()
{
	int u,v,w,idx;
	char cmd[10];
    scanf("%d",&n);
    //for(int i=1;i<=n;i++) scanf("%d",&val[i]);
    for(int i=1;i<n;i++)
	{
        scanf("%d%d%d",&u,&v,&w);
        AddEdge(u+1,v+1,w); AddEdge(v+1,u+1,w);
    }
    
    dfs1(1 , 0);
    dfs2(1 ,0, 1);
    
	build(1,1,n);
	scanf("%d",&m);
	
    while(m--)
	{
        scanf("%s",cmd);
        if(cmd[0]=='C')
        {
        	scanf("%d%d",&idx,&w);
        	u=e[idx*2-1].u; v=e[idx*2-1].v;
        	if(h[u]<h[v])
        	{
        		PointChange(1,1,n,pos[v],w);
			}
			else
			{
				PointChange(1,1,n,pos[u],w);
			}
		}
        else if(cmd[0]=='N') 
        {
        	scanf("%d%d",&u,&v);
        	update(u+1,v+1);
		}
		else if(cmd[0]=='S')
		{
			scanf("%d%d",&u,&v);
			printf("%d\n",FindSum(u+1,v+1));
		}
		else if(cmd[1]=='A')
		{
			scanf("%d%d",&u,&v);
			printf("%d\n",FindMax(u+1,v+1));
		}
		else if(cmd[1]=='I')
		{
			scanf("%d%d",&u,&v);
			printf("%d\n",FindMin(u+1,v+1));
		}
    }
    
	return 0;
}
王江奎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【HYSBZ 4034 】树链剖分+线段树
fedsnly的博客
08-09 175
有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个 操作，分为三种： 操作 1 ：把某个节点 x 的点权增加 a 。 操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。 操作 3 ：询问某个节点 x 到根的路径中所有点的点权和。 Input 第一行包含两个整数 N, M 。表示点数和操作数。接下来一行 N 个整数，表示树中节点的初始权值。接下来 N-1...
#213-[树链剖分]树(GDKOI2015)
2017gdgzoi999的博客
03-26 623
Description 给定一棵树，树节点编号为 0~N-1 的，根的节点编号为 0，每个节点有初始颜色 c 和权值 v，现在有三种操作： 1.Change u x y，表示将 u 的子树中颜色为 x 和 y 的节点颜色反转，即将 x 颜色的的节点换成 y 颜色，将 y 颜色的节点换成 x 颜色。数据保证 x 与 y 不相等。 2.Ask u v c，表示询问 u 到 v 的路径上，颜色为 c ...
HYSBZ - 2243(树链剖分)
Soul
12-08 191
题解:在树上路径的查询一看就是树链剖分,然后查询是如何查询呢,如果我这条链的头结点颜色和其父节点颜色一样那么我们答案就要减一,更新线段树的用一个l，r记录最右端和最左端的颜色,如果左区间的右端点颜色和右区间的左端点颜色一样那么就要合并减去一段即可 #include #include #include #include using namespace std; #define root 1,1,n
树的统计Count HYSBZ - 1036 (树链剖分，点更，区间最值，和查询)
GameRoad
06-03 333
思路： 裸树链剖分+线段树。给出的是点，直接做就好，注意有-值 #pragma comment(linker, "/STACK:102400000,102400000") #include #include #include #include using namespace std; const int inf=0x3f3f3f3f; const int maxn = 300
树上操作 HYSBZ - 4034 树链剖分
M_theory004的博客
11-03 184
和去年新生赛类似的题 #include<iostream> #include<vector> #include<algorithm> #include<string> #include<stack> #include<cstring> #include<set> #include<iterator...
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链剖分（含例题）
zyc_____的博客
05-04 429
树链剖分介绍： 模板题：【模板】最近公共祖先（LCA） - 洛谷 图片来自：通俗易懂的树链剖分详解 - 一剑缥缈的洛咕博客 - 洛谷博客 树链剖分的优点： 求LCA中的优化无非就是减少无效搜索的次数，树链剖分把树拆成不同的链（保证不重不漏），因为两个点的LCA一定在一条链上（同一个点），所以如果搜索到的点不在同一条链上，那么不是倍增跳或是······，而是跳过一整条链，这样搜索的速度会大幅提高。 注释代码： #include<bits/stdc++.h> using names.
CodeForces - 786C——二分+模拟？
T_T233333333的博客
08-20 3836
【题目描述】 Rick and Morty want to find MR. PBH and they can't do it alone. So they need of Mr. Meeseeks. They Have generated n Mr. Meeseeks, standing in a line numbered from 1 to n. Each of them has his o...
CodeChef - DGCD——树链剖分+差分
T_T233333333的博客
08-21 403
【题目描述】 You're given a tree on N vertices. Each vertex has a positive integer written on it, number on the ith vertex being vi. Your program must process two types of queries : 1. Find query represe...
CodeForces - 372CWatching Fireworks is Fun+DP+单调队列优化
T_T233333333的博客
08-12 385
【题目描述】 CodeForces - 372CWatching Fireworks is Fun 题目的大概意思就是在一个编号为1…n的街道上现在按照时间顺序放烟花，每个烟花获得的幸福感为b−abs(a−x)b-abs(a-x)b−abs(a−x)，x为观看烟花的位置，为了提升我们的幸福感，我们可能会移动，每个时间单位可以移动d长度，现在问我们如果可以从任何一个地点开始观看烟花，那么最后幸福感最...
HDU - 1028——母函数入门
T_T233333333的博客
08-15 355
【题目描述】 “Well, it seems the first problem is too easy. I will let you know how foolish you are later.” feng5166 says. “The second problem is, given an positive integer N, we define an equation like thi...
BZOJ1123-BLO——强连通分量求割点+计数
T_T233333333的博客
08-19 300
【题目描述】 Byteotia城市有n个 towns m条双向roads. 每条 road 连接 两个不同的 towns ,没有重复的road. 所有towns连通。 Input 输入n<=100000 m<=500000及m条边 Output 输出n个数，代表如果把第i个点去掉，将有多少对点不能互通。 Sample Input 5 5 1 2 2 3 1 3 3 4 4 5 ...
强连通分量入门——Trajan算法
T_T233333333的博客
08-16 298
今天学习了强连通分量。 【参考博客】 如果觉得我讲的有些地方难以理解或者存在问题（欢迎留言），可以看一下我借鉴的一些大佬的博客： 传送门1 传送门2 【知识储备】 首先我们需要对几个定义有一些概念： 强连通：有向图中两个点可以相互到达 强连通图：有向图中任意两个点都是强连通的 强连通分量：一个有向图的一个子图中是强连通图的最大的子图就称这个有向图为强连通分量 通俗理解的话，强连通分量里面的任何两...
HDU - 6278 Just $h$-index主席树+二分
T_T233333333的博客
07-30 264
HDU - 6278 Just hhh-index 【题目描述】 【题目分析】 题目要求在区间[l,r][l,r][l,r]内大于h的数不少于h个，对于这种最大化问题，我们应该想到二分。 最小情况显然是1.最大情况显然是r−l+1r-l+1r−l+1，对于一个hhh，我们如何判断能否满足条件呢？ 我们可以用主席树方便的求出区间第h大，如果区间第h大大于等于h，那么就能满足条件 比较伤心的是我虽然...
CodeForces - 1141CPolycarp Restores Permutation搜索+剪枝
T_T233333333的博客
07-21 250
Polycarp Restores Permutation 【题意分析】题意大概是给定一个串，包含从1到n所有的数字。但是给定的是相邻数字的差，需要复原这个串。 大概分析以后发现给定的是一个差分数组，所以只需要枚举第一个元素就可以确定所有元素的值。 问题是如何判断可行，一个一个判断显然是不行的——会超时。 剪枝技巧1：在得到差分数组的时候记录最小值和最大值，a[1]+最小值肯定是1，a[1]+最大...
POJ 3370 Halloween treats——鸽巢原理+思维
T_T233333333的博客
08-13 226
【题目描述】 POJ 3370 Halloween treats Description Every year there is the same problem at Halloween: Each neighbour is only willing to give a certain total number of sweets on that day, no matter how many ...
CodeForces - 1152B二进制+思维
T_T233333333的博客
07-22 226
【题目链接】Neko Performs Cat Furrier Transform 【题目分析】要求将一个数字变成2n-1,通过尝试我们发现如果将最低位的全零位和对应的全一数字（例如11000对应的就是111）异或那么数字就会变成想要的结果（11111） 但是如果前面还有0（比如110100）那么过程应该如下：110100^000011变成110111加一后变成111000然后就会得到结果，总之我...
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值