HDU 5296 Annoying Problem 树链剖分 LCA 倍增法

最新推荐文章于 2019-04-15 18:50:55 发布
原创 最新推荐文章于 2019-04-15 18:50:55 发布 · 809 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了HDU5296 Annoying Problem的解题思路，包括如何通过树链剖分、线段树、倍增等数据结构和算法解决该问题。主要内容涉及节点集合S的维护、LCA（最近公共祖先）的查找、关键节点的确定及边权重的更新，最终输出使集合S中所有点联通的最小子树的边权和。

HDU 5296 Annoying Problem

题目链接：hdu 5296

题意：在一棵给定的具有边权的树，一个节点的集合S（初始为空），给定Q个操作，每个操作增加或删除S中的一个点，每个操作之后输出使集合S中所有点联通的最小子树的边权和。

思路：最小子树上的节点的充要条件：

  • 节点为（S集合中所有点的LCA）的子节点；
  • 节点有一个子孙为S集合中的点。

那么我们给每个节点都开一个标记数组，初始为零，每加入一个节点，就把从这个节点到根节点路径上的点的值都+1，反之-1，这样通过对每个单节点值的查询就能知道它是不是最小子树上的节点。
然后对于每一次节点的增加和删除都有两种情况：
第一种：加入或删除新节点不会改变最小子树的根节点，那么就必然存在一个节点是这个新节点的祖先，那么我们找到这个深度最深的祖先在最小子树中的祖先就是关键节点，可以倍增求；
第二种：加入或删除新节点会改变最小子树的根节点，那么这个关键节点就是旧子树的根节点。
求得关键节点之后直接加上或减去两点之间的边的权值和就OK。

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
#include <queue>
#include <set>
#include <algorithm>
#define Lson o<<1,l,mid
#define Rson o<<1|1,mid+1,r
using namespace std;
const int maxn=120010+5;//最大节点数
const int maxm =maxn*2;//最大边条数
const int DEG =20;

int v[maxm];//v[i]表示第i条边指向的节点
int Prev[maxm];//Prev[i]表示i的兄弟边
int ed[maxm][3];//存储的是边的信息
int info[maxn];//表示最后插入的与节点i相连的边
int Q[maxn];//用于实现队列和栈
int idx[maxn];//存储的是节点i在所属链的编号 从叶子到根依次增加
int dep[maxn];//节点的深度
int size[maxn];//链的轻重
int belong[maxn];//表示节点i所属边的编号
int father[maxn];//节点i的直接父亲
bool vis[maxn];//剖分回溯时使用的标记
int head[maxn];//第i条链的头部节点
int len[maxn];//第i条链的长度
int l,r,ans,cnt=0;//cnt为链的条数
int N,nedge=0;//nedge为边的条数 N为总点数
int pos[maxn];//树链剖分后各店的位置
int val[maxn];//求得节点到根节点所经过边的权值和
int rk[maxn];//节点的DFS序
int frk[maxn];//DFS序的反函数
int fa[maxn][DEG];//节点i的2^j倍祖先
/******************树链剖分部分****************************/
//树链剖分部分
inline void insert(int x,int y,int c){
    ++nedge;
    v[nedge]=y;Prev[nedge]=info[x];info[x]=nedge;
    ed[nedge][0]=x;ed[nedge][1]=y;ed[nedge][2]=c;
}
void split(){
    memset(dep,-1,sizeof(dep));
    l=0;
    dep[Q[r=1]=1]=0;
    father[1]=-1;
    while(l<r){
        int x=Q[++l];
        vis[x]=false;
        for(int y=info[x];y!=-1;y=Prev[y]){
            if(dep[v[y]]==-1){
                dep[Q[++r]=v[y]]=dep[x]+1;
                father[v[y]]=x;
            }
        }

    }

    for(int i=N;i;i--){
        int x=Q[i],p=-1;
        size[x]=1;
        for(int y=info[x];y!=-1;y=Prev[y]){
            if(vis[v[y]]){
                size[x]+=size[v[y]];
                if(p==-1||size[v[y]]>size[p])
                    p=v[y];
            }
        }
        if(p==-1){
            idx[x]=len[++cnt]=1;
            belong[head[cnt]=x]=cnt;
        }
        else {
            idx[x]=++len[belong[x]=belong[p]];
            head[belong[x]]=x;
        }
        vis[x]=true;
    }
}
void get_pos(){
    int Pos[maxn];
    Pos[1]=0;
    for(int i=2;i<=cnt;i++)Pos[i]=Pos[i-1]+len[i-1];
    for(int i=1;i<=N;i++)pos[i]=Pos[belong[i]]+idx[i];
}

/******************线段树部分****************************/
//区间修改单点查询  也可以使用树状数组
int addv[maxn*4];
void push_down(int o,int l,int r){
    if(l==r) return ;
    addv[o<<1]+=addv[o];
    addv[o<<1|1]+=addv[o];
    addv[o]=0;
}

void update(int o,int l,int r,int L,int R,int val){
    if(L<=l&&R>=r){
        addv[o]+=val;
    }
    else {
        push_down(o,l,r);
        int mid=(l+r)>>1;
        if(L<=mid)update(Lson,L,R,val);
        if(R>mid)update(Rson,L,R,val);
    }
}
int quarry(int o,int l,int r,int pos){
    if(l==r) return addv[o];
    push_down(o,l,r);
    int mid=(l+r)>>1;
    if(pos>mid)return quarry(Rson,pos);
    else return quarry(Lson,pos);
}



/******************剖分后对树的边修改部分********************/

void change(int a,int b,int val){
    int fu=head[belong[a]],fv=head[belong[b]];
    while(fu!=fv){
        update(1,1,N,pos[b],pos[fv],val);
        b=father[fv];
        fv=head[belong[b]];
    }
    update(1,1,N,pos[b],pos[a],val);

}


/***************BFS求得倍增关系和到根节点边的权值和************/

void bfs(int root){
    for(int i=1;i<=nedge;i++){
        if(dep[ed[i][0]]<dep[ed[i][1]])continue;
        val[ed[i][0]]=ed[i][2];
    }
    fa[root][0]=root;
    dep[root]=0;
    l=r=0;
    val[root]=0;
    Q[r++]=root;
    while(l<r){
        int u=Q[l++];
        val[u]=val[u]+val[fa[u][0]];
        for(int i=1;i<DEG;i++){
            fa[u][i]=fa[fa[u][i-1]][i-1];
        }
        for(int i=info[u];i!=-1;i=Prev[i]){
            int drc=v[i];
            if(drc==father[u])continue;
            dep[drc]=dep[u]+1;
            fa[drc][0]=u;
            Q[r++]=drc;
        }
    }
}


/*********************求DFS序及其反函数**********************/
void fdg(int root){

    int tt=0;
    Q[tt++]=root;
    rk[root]=0;
    int rr=0;
    while(tt>0){
        int u=Q[--tt];
        rk[u]=rr++;
        for(int i=info[u];i!=-1;i=Prev[i]){
            int drc=v[i];
            if(drc==fa[u][0])continue;
            Q[tt++]=drc;
        }
    }
    for(int i=1;i<=N;i++){
        frk[rk[i]]=i;
    }
}
/*******************倍增法求LCA******************************/
int lca(int a,int b){
    if(dep[a]>dep[b])swap(a,b);
    int hu=dep[a],hv=dep[b];
    int tu=a,tv=b;
    for(int i=0,tt=hv-hu;tt;i++,tt/=2){
        if(tt&1) tv=fa[tv][i];
    }
    if(tu==tv) return tu;
    for(int i=DEG-1;~i;i--){
        if(fa[tu][i]==fa[tv][i])continue;
        tu=fa[tu][i];
        tv=fa[tv][i];
    }
    return fa[tu][0];
}
/********************求当前集合的LCA***********************/
set<int> Set;
set<int>::iterator it;
int get_lca(){
    if(Set.empty())
        return -1;
    if(Set.size()==1){
        return frk[*Set.begin()];
    }
    else {
        it=Set.end();
        it--;
        return lca(frk[*Set.begin()],frk[*it]);
    }
}

/*******************倍增法求关键节点*************************/

int get_key_node(int u){
    if(quarry(1,1,N,pos[u])) return u;
    for(int i=DEG-1;~i;i--){
        int tp=quarry(1,1,N,pos[fa[u][i]]);
        if(tp)continue;
        u=fa[u][i];
    }
    return fa[u][0];
}

/****初始化****/
void init(){
    memset(addv,0,sizeof(addv));
    nedge=0;
    Set.clear();
    cnt=0;
    memset(info,-1,sizeof(info));
}
/**********分情况处理询问***************/
void solve(int a,int b){
    int lca1,lca2;
    int key_node;
    if(a==1){
        if(Set.find(rk[b])==Set.end()){
            lca1=get_lca();
            Set.insert(rk[b]);
            lca2=get_lca();
            if(lca1==-1){
                change(1,b,1);
            }
            else {
                if(lca2==lca1){
                    key_node=get_key_node(b);
                    ans+=(val[b]-val[key_node]);
                }
                else {
                    ans+=(val[b]+val[lca1]-2*val[lca2]);
                }
                change(1,b,1);
            }
        }
    }
    else {
        if(Set.find(rk[b])!=Set.end()){
            lca1=get_lca();
            Set.erase(rk[b]);
            lca2=get_lca();
            change(1,b,-1);
            if(lca2==-1){
            }
            else {
                if(lca1==lca2){
                    key_node=get_key_node(b);
                    ans-=(val[b]-val[key_node]);
                }
                else {
                    ans-=(val[b]+val[lca2]-2*val[lca1]);
                }
            }
        }
    }
}
int main(){
//    freopen("100.in","r",stdin);
//    freopen("data.out","w",stdout);
    int T,M,cas=0;
    scanf("%d",&T);
    while(T--){
        init();
        printf("Case #%d:\n",++cas);
        scanf("%d%d",&N,&M);
        int a,b,c;
        for(int i=1;i<N;i++){
            scanf("%d%d%d",&a,&b,&c);
            insert(a,b,c);
            insert(b,a,c);
        }
        split();
        get_pos();
        bfs(1);
        fdg(1);
        ans=0;
        while(M--){
            scanf("%d%d",&a,&b);
            solve(a,b);
            printf("%d\n",ans);
        }
    }
    return 0;
}

另外刚刚游泳的时候想到了一个方法不用倍增。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
#include <queue>
#include <set>
#include <algorithm>
#define Lson o<<1,l,mid
#define Rson o<<1|1,mid+1,r
using namespace std;
const int maxn=120010+5;//最大节点数
const int maxm =maxn*2;//最大边条数
const int DEG =20;
int v[maxm];//v[i]表示第i条边指向的节点
int Prev[maxm];//Prev[i]表示i的兄弟边
int ed[maxm][3];//存储的是边的信息
int info[maxn];//表示最后插入的与节点i相连的边
int Q[maxn];//用于实现队列和栈
int idx[maxn];//存储的是节点i在所属链的编号 从叶子到根依次增加
int dep[maxn];//节点的深度
int size[maxn];//链的轻重
int belong[maxn];//表示节点i所属边的编号
int father[maxn];//节点i的直接父亲
bool vis[maxn];//剖分回溯时使用的标记
int head[maxn];//第i条链的头部节点
int len[maxn];//第i条链的长度
int l,r,ans,cnt=0;//cnt为链的条数
int N,nedge=0;//nedge为边的条数 N为总点数
int pos[maxn];//树链剖分后各店的位置
int val[maxn];//求得节点到根节点所经过边的权值和
int rk[maxn];//节点的DFS序
int frk[maxn];//DFS序的反函数
/******************树链剖分部分****************************/
//树链剖分部分
inline void insert(int x,int y,int c){
    ++nedge;
    v[nedge]=y;Prev[nedge]=info[x];info[x]=nedge;
    ed[nedge][0]=x;ed[nedge][1]=y;ed[nedge][2]=c;
}
void split(){
    memset(dep,-1,sizeof(dep));
    l=0;
    dep[Q[r=1]=1]=0;
    father[1]=-1;
    while(l<r){
        int x=Q[++l];
        vis[x]=false;
        for(int y=info[x];y!=-1;y=Prev[y]){
            if(dep[v[y]]==-1){
                dep[Q[++r]=v[y]]=dep[x]+1;
                father[v[y]]=x;
            }
        }

    }

    for(int i=N;i;i--){
        int x=Q[i],p=-1;
        size[x]=1;
        for(int y=info[x];y!=-1;y=Prev[y]){
            if(vis[v[y]]){
                size[x]+=size[v[y]];
                if(p==-1||size[v[y]]>size[p])
                    p=v[y];
            }
        }
        if(p==-1){
            idx[x]=len[++cnt]=1;
            belong[head[cnt]=x]=cnt;
        }
        else {
            idx[x]=++len[belong[x]=belong[p]];
            head[belong[x]]=x;
        }
        vis[x]=true;
    }
}
void get_pos(){
    int Pos[maxn];
    Pos[1]=0;
    for(int i=2;i<=cnt;i++)Pos[i]=Pos[i-1]+len[i-1];
    for(int i=1;i<=N;i++)pos[i]=Pos[belong[i]]+idx[i];
}
/******************线段树部分****************************/
//区间修改单点查询  也可以使用树状数组
int addv[maxn*4];
void push_down(int o,int l,int r){
    if(l==r) return ;
    addv[o<<1]+=addv[o];
    addv[o<<1|1]+=addv[o];
    addv[o]=0;
}
void update(int o,int l,int r,int L,int R,int val){
    if(L<=l&&R>=r){
        addv[o]+=val;
    }
    else {
        push_down(o,l,r);
        int mid=(l+r)>>1;
        if(L<=mid)update(Lson,L,R,val);
        if(R>mid)update(Rson,L,R,val);
    }
}
int quarry(int o,int l,int r,int pos){
    if(l==r) return addv[o];
    push_down(o,l,r);
    int mid=(l+r)>>1;
    if(pos>mid)return quarry(Rson,pos);
    else return quarry(Lson,pos);
}
/******************剖分后对树的边修改部分****************************/

void change(int a,int b,int val){
    int fu=head[belong[a]],fv=head[belong[b]];
    while(fu!=fv){
        update(1,1,N,pos[b],pos[fv],val);
        b=father[fv];
        fv=head[belong[b]];
    }
    update(1,1,N,pos[b],pos[a],val);

}
/*********************求DFS序及其反函数**************************/
void fdg(int root){
    for(int i=1;i<=nedge;i++){
        if(dep[ed[i][0]]<dep[ed[i][1]])continue;
        val[ed[i][0]]=ed[i][2];
    }
    val[root]=0;
    int tt=0;
    Q[tt++]=root;
    rk[root]=0;
    int rr=0;
    while(tt>0){
        int u=Q[--tt];
        rk[u]=rr++;
        val[u]=val[u]+val[father[u]];
        for(int i=info[u];i!=-1;i=Prev[i]){
            int drc=v[i];
            if(drc==father[u])continue;
            Q[tt++]=drc;
        }
    }
    for(int i=1;i<=N;i++){
        frk[rk[i]]=i;
    }
}
/*******************求LCA******************************/
int lca(int a,int b){
    int fu=head[belong[a]],fv=head[belong[b]];
    if(dep[fu]>dep[fv]){
        swap(fu,fv);
    }
    while(fu!=fv){
        b=father[fv];
        fv=head[belong[b]];
        if(dep[fu]>dep[fv]){
            swap(fu,fv);
            swap(a,b);
        }
    }
    if(dep[a]>dep[b])swap(a,b);
    return a;
}
/**********************求当前集合的LCA***********************/
set<int> Set;
set<int>::iterator it;
int get_lca(){
    if(Set.empty())
        return -1;
    if(Set.size()==1){
        return frk[*Set.begin()];
    }
    else {
        it=Set.end();
        it--;
        return lca(frk[*Set.begin()],frk[*it]);
    }
}

/*******************求关键节点*************************/

int get_key_node(int u){
    int fu=head[belong[u]];
    while(!quarry(1,1,N,pos[fu])){
        u=father[fu];
        fu=head[belong[u]];
    }
    while(!quarry(1,1,N,pos[u])){
        u=father[u];
    }
    return u;
}

/****初始化****/
void init(){
    memset(addv,0,sizeof(addv));
    nedge=0;
    Set.clear();
    cnt=0;
    memset(info,-1,sizeof(info));
}
/**********分情况处理询问***************/
void solve(int a,int b){
    int lca1,lca2;
    int key_node;
    if(a==1){
        if(Set.find(rk[b])==Set.end()){
            lca1=get_lca();
            Set.insert(rk[b]);
            lca2=get_lca();
            if(lca1==-1){
                change(1,b,1);
            }
            else {
                if(lca2==lca1){
                    key_node=get_key_node(b);
                    ans+=(val[b]-val[key_node]);
                }
                else {
                    ans+=(val[b]+val[lca1]-2*val[lca2]);
                }
                change(1,b,1);
            }
        }
    }
    else {
        if(Set.find(rk[b])!=Set.end()){
            lca1=get_lca();
            Set.erase(rk[b]);
            lca2=get_lca();
            change(1,b,-1);
            if(lca2==-1){
            }
            else {
                if(lca1==lca2){
                    key_node=get_key_node(b);
                    ans-=(val[b]-val[key_node]);
                }
                else {
                    ans-=(val[b]+val[lca2]-2*val[lca1]);
                }
            }
        }
    }
}
int main(){
//    freopen("100.in","r",stdin);
//    freopen("data.out","w",stdout);
    int T,M,cas=0;
    scanf("%d",&T);
    while(T--){
        init();
        printf("Case #%d:\n",++cas);
        scanf("%d%d",&N,&M);
        int a,b,c;
        for(int i=1;i<N;i++){
            scanf("%d%d%d",&a,&b,&c);
            insert(a,b,c);
            insert(b,a,c);
        }
        split();
        get_pos();
        fdg(1);
        ans=0;
        while(M--){
            scanf("%d%d",&a,&b);
            solve(a,b);
            printf("%d\n",ans);
        }
    }
    return 0;
}
HDU 5293 树链剖分 + 树形DP
新熊君的博客
02-03 498
题目链接题意： 给定有nn个节点的树和mm条链(链连接两个顶点，且有权值)，要求选出一部分链，使连接以后图的每个圈没有公共节点，问能够选出的链的权值和最大为多少？考虑树形DP。对于当前顶点uu，假设dp[u]dp[u]为以uu为根节点的子树所能够达到的最大目标值。 另外定义： 1.ww为当前考虑的链权值。 2.sum[u]=∑dp[k]sum[u] = \sum dp[k](kk为uu的子节
HDU 5293 Tree chain problem（树形DP+树链剖分+LCA）
GODSPEED
10-29 575
题意：给出一棵有n个结点的树，树上有m条链，每条链有一个权值，选出最多没有重复节点的链，使得权值和最大。 思路：树形DP+树链剖分+LCA。首先处理出每条链两个端点的LCA并保存起来。 用dp[i]表示以i为根节点的子树的最大值，sum[i]表示i的儿子节点的dp值的和，即sigma(dp[j])，j是i的儿子节点。 这样状态转移方程也可以得出，当i节点不放链的话，dp[i] = sum[i
hdu 5296 Annoying problem(LCA)
不慌不忙、不急不躁
07-31 861
题目链接：hdu 5296 Annoying problem 先求出dfs序，然后每次修改一个节点u，找到dfs最接近u的两个点，a，b的dfs序分别大于和小于u的。修改值即为dp[u] - dp[lca(a,u)] - dp[lca(b,u)] + dp[lca(a, b)]，dp[i]表示i到根节点的权值和。但集合中的节点的dfs序都大于或小于u时，a，b即用最大和最小的即可。
HDU 5296 Annoying problem（LCA模板+树的dfs序心得）
Must so
07-25 1804
Problem Description Coco has a tree, whose nodes are conveniently labeled by 1,2,…,n, which has n-1 edge，each edge has a weight. An existing set S is initially empty. Now there are two kinds of op
hdu5296 Annoying problem (LCA+SET)
w20810的专栏
07-26 1158
题目：http://acm.hdu.edu.cn/showproblem.php?pid=5296 题意：给定N个点和N-1条边以及边的权值,再给定一个set,向set里面添加/删除节点求让set里面的节点连通的最小费用。 分析：看大神博客知道的。这题主要求点到链的距离。先解决点到点的距离,假如dis[x]表示x到root的距离,那么点u和v的距离就是dis[u]+dis[v]-dis[lca
HDU 3966 树链剖分
Dan__ge的博客
07-10 1539
点击打开链接 题意：给一个树，三个操作，一个询问点的权值，一个将u到v路径上的点的权值增加，一个是减少 思路：还是比较裸的模版题，线段树改为区间更新就好了#pragma comment(linker, "/STACK:1024000000,1024000000") #include #include #include #include #include #include using
HDU5266 LCA 树链剖分LCA 线段树
ezoiHY
08-16 2771
HDU5266 LCA Description 给一棵 n 个点的树，Q 个询问 [L,R] : 求点 L , 点 L+1 , 点 L+2 …… 点 R 的 LCA. Input 多组数据. The following line contains an integers,n(2≤n≤300000). AT The following n−1 line, two integers...
HDU 5296 Annoying problem LCA+树状数组
九野的博客
07-22 1579
题解链接 Annoying problem Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 480    Accepted Submission(s): 146 Problem Description
[HDU 5296] Annoying problem （DFS序性质+LCA）
MisDeer's blog
07-19 858
HDU - 5296 一棵树上有若干个点，每条边有一个边权 给一个初始为空的集合，每次向集合内添加一个点或者删除一个点 问每次操作结束后，将集合内所有点连起来的边权和为多少 假设集合内已经有一些点，那么再加一个点所增加的边权 将会是这个点到某一条链的距离但是这条链不能随便挑选，否则可能会经过已经选择的边 挑选策略就是，找到集合内dfsdfs序比当前点大和小的两个点组成的链 换句
HDU 5296 Annoying problem
long long ago
07-22 1734
Annoying problem Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 203    Accepted Submission(s): 60 Problem Description Coco has a
倍增法在线求LCA（详解）
m0_37579232的博客
04-15 1743
先贴上学习的文章： 洛谷P3379题解1 倍增讲解 在用Tarjan算法求LCA时会出现超时的现象，因为是一层一层的往上跳，于是就有了用倍增法求LCA，是层地往上跳。复杂度：O(nlogn) 1.倍增法思想： 按2的倍数跳，不过是从大到小跳，32,16,8,4,2,1。原因是从小到大跳会出现“悔棋”的现象： 从小到大：5!=1+2+4 从大到小：5=4+1 5<32 （不跳）...
树链剖分之HLD
RBS的专栏
01-02 2847
树链剖分的原理对于数组这样的线性结构，要在其上实现区间查询（和与最值）、区间修改甚至是区间增删都是有办法的。例如Sparse Table算法、树状数组、线段树以及伸展树等。而树是一种非线性结构，为了高效的实现在树上的路径查询、路径修改操作，基本做法是将树按照某种方式剖成若干条链，再将这些链按照顺序组成数组，最后在数组上采用线段树等手段实现操作。 考虑如下一棵树： 可以把它剖成6条链，分别是A
HDU 5221 树链剖分
新熊君的博客
07-20 585
题目链接题意很简单。对于前两个操作，一个是树链剖分的经典路径更新，另外一个是线段的单点更新。难点就在于第三个操作怎么来处理。关于子树的更新，很显然跟dfs序有关，如果观察第二个更新重链的dfs，易发现，其实标号的过程也是一个dfs序的过程，只不过优先走的重儿子的路径。而关于标号跟子树的关系，可以看下图：（图片来源于网络 侵删）易看出 以u为根节点的子树的标号一定连续，且为： tid[u]−−>tid
【HDU 2586】【LCA总结】Tarjan | ST表RMQ | 倍增 | 树链剖分 | 树上多源最短路 | E
Keyu Tian's blog
04-13 556
以【HDU 2586】How far away ？为例，介绍LCA的四种求法：倍增、RMQ、树剖和Tarjan（怎么又是你） 题目描述 给定一棵无向树，有 $q$ 次查询，每次询问两个结点的最短路距离。
HDU 5293 Tree chain problem（树形DP+树链剖分）
Neutralzz的博客
07-06 469
题意：一颗n节点树上有m条链，每条链有权重，求一个链的集合使权重和最大且两两不相交。 解析：令dp[i]为以i为根的子树的最大权重和。 如果i不在链上，则有dp[i] = sigma(dp[k]) k为i的子节点 如果i在某一条链(u,v,w)上，那么dp[i] = w + sigma(dp[k]) k为链上所有节点的子节点。对于该值，我们可以统计统计链上节点的所有子节点dp的和 - 链上节
【嵌入式AIoT】系统架构与轻量化模型部署：面向智能家居与工业监测的边缘智能终端实战设计
12-21
内容概要：本文系统介绍了嵌入式AIoT应用场景的实战方法与实践路径，涵盖从场景选择、系统架构设计到AI模型部署、通信与数据管理的全流程。重点阐述了嵌入式系统与人工智能、物联网技术的融合，强调在资源受限环境下实现感知、分析与决策一体化的智能终端系统。文章详细解析了感知层、边缘计算层和云端服务层的协同机制，突出边缘侧数据处理与轻量化AI模型优化的重要性，并倡导以实际需求为导向，避免“为AI而AI”的设计误区。同时，强调系统稳定性、远程维护和长期运行能力的建设。; 适合人群：具备嵌入式系统基础、物联网或AI相关背景，有一定开发经验的工程师或工作1-3年的技术研发人员；适用于希望深入理解AIoT系统集成与实战落地的学习者。; 使用场景及目标：①智能家居、工业监测、智慧农业等分布式智能系统开发；②在算力、功耗受限的嵌入式设备上实现AI推理与边缘智能；③构建高效、可靠、可维护的端云协同AIoT系统。; 阅读建议：建议结合实际硬件平台进行项目化学习，边学边练，重点关注系统架构设计、模型优化与通信协议选型，注重整体系统思维的培养，而非仅关注单一技术点。
基于Python 的UART 文件传输工具
最新发布
12-21
基于Python 的UART 文件传输工具，基于Pyside6的GUI界面
C# 基于 Onnx 与 P2PNet 的人群检测与计数系统源码实现
12-21
基于C#编程语言与Onnx运行时环境，本文档详细阐述了一种利用P2PNet架构实现人群密度估计与个体计数的技术方案。该方案通过解析预训练模型，实现了对图像或视频流中人群分布的精准检测，并提供了可靠的计数功能。核心内容包括模型加载与推理流程的完整实现、数据处理管道的构建以及性能优化策略的探讨。本文旨在为相关领域的开发人员提供一个清晰、可复现的参考实现，着重于工程实践的严谨性与代码模块的可用性。所有实现代码均经过结构化组织与详细注释，以确保其易于理解与集成。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
Theoretical Machine Learning Notes (Princeton COS511)
12-21
根据原作 https://pan.quark.cn/s/459657bcfd45 的源码改编 Classic-ML-Methods-Algo 引言 建立这个项目,是为了梳理和总结传统机器学习(Machine Learning)方法(methods)或者算法(algo),和各位同仁相互学习交流. 现在的深度学习本质上来自于传统的神经网络模型,很大程度上是传统机器学习的延续,同时也在不少时候需要结合传统方法来实现. 任何机器学习方法基本的流程结构都是通用的;使用的评价方法也基本通用;使用的一些数学知识也是通用的. 本文在梳理传统机器学习方法算法的同时也会顺便补充这些流程,数学上的知识以供参考. 机器学习 机器学习是人工智能(Artificial Intelligence)的一个分支,也是实现人工智能最重要的手段.区别于传统的基于规则(rule-based)的算法,机器学习可以从数据中获取知识,从而实现规定的任务[Ian Goodfellow and Yoshua Bengio and Aaron Courville的Deep Learning].这些知识可以分为四种: 总结（summarization） 预测(prediction) 估计(estimation) 假想验证(hypothesis testing) 机器学习主要关心的是预测[Varian在Big Data : New Tricks for Econometrics],预测的可以是连续性的输出变量,分类,聚类或者物品之间的有趣关联. 机器学习分类 根据数据配置(setting,是否有标签，可以是连续的也可以是离散的)和任务目标,我们可以将机器学习方法分为四种: 无监督(unsupervised) 训练数据没有给定...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值