树形DP汇总

已于 2022-02-09 10:53:40 修改
阅读量283 收藏 2
点赞数
分类专栏： DP 文章标签： 深度优先 动态规划 算法
于 2022-02-08 22:14:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51282224/article/details/122790154
版权

树形DP题型复盘

一、最长路径问题

(1)边权最长路径

1.树的最长路径—树形DP

题目链接
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 20010;
int e[N],ne[N],h[N],w[N],idx=0;
int n;
int res=0;
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int dfs(int u,int fa)
{
    int d1=0,d2=0;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        int d=dfs(j,u)+w[i];
        if(d>=d1)d2=d1,d1=d;
        else if(d>d2)d2=d;
    }
    res=max(d1+d2,res);
    return d1;
}
int main()
{
    cin>>n;
    memset(h, -1, sizeof h);
    for(int i=1;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs(1,-1);
    cout<<res<<endl;
}

2.大臣的旅费—非负权值贪心写法

题目链接
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010;
int n;
int h[N],e[N*2],w[N*2],ne[N*2],idx;
int dist[N];
void add(int a,int b,int c){
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int father,int distance){
    dist[u]=distance;
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];
        if(j!=father)
        dfs(j,u,distance+w[i]);
    }
}
int main()
{
    cin>>n;
    memset(h,-1,sizeof h);
    for(int i=0;i<n-1;i++){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs(1,-1,0);
    int u=1;
    for(int i=2;i<=n;i++){
        if(dist[u]<dist[i])u=i;
    }
    dfs(u,-1,0);
    for(int i=1;i<=n;i++)
     if(dist[u]<dist[i])
       u=i;
    printf("%lld\n",dist[u]*10+(dist[u]+1ll)*dist[u]/2);

}

(2).点权最长路径

1.树上子链—树形DP

题目链接
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#define int long long
const int N = 200010,INF=0x3f3f3f3f;
int e[N],ne[N],w[N],h[N],idx=0;
int n;
int f[N];
int res=-INF;
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int fa)
{
    f[u]=w[u];
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        dfs(j,u);
        res=max(res,f[u]+f[j]);
        f[u]=max(f[u],f[j]+w[u]);
    }
    res=max(res,f[u]);
}
signed main()
{
    cin>>n;
    memset(h,-1,sizeof h);
    for(int i=1;i<=n;i++)cin>>w[i];
    for(int i=1;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
        add(b,a);
    }
    dfs(1,-1);
    cout<<res<<endl;
}

二、有依赖的背包问题

（1）点权依赖问题

1.有依赖的背包问题—树形DP

题目链接

这道题比较难思考的地方在于按照体积划分，如果像金明的预算方案那一题去进行二进制枚举的话是一定会超时的，因此这个题不按方案划分，按照体积划分。

同时因为依赖性，每次根节点必须选择后才能选择子节点，在最前边加上 f [ u ] [ v [ u ] ] = w [ u ] f[u][v[u]]=w[u] f[u][v[u]]=w[u]
有些人是这样写的 f o r ( i n t i = v [ u ] ; i < = m ; i + + ) f [ u ] [ i ] = w [ u ] for(int i=v[u];i<=m;i++) f[u][i]=w[u] for(inti=v[u];i<=m;i++)f[u][i]=w[u]

后面的其实不需要处理，根据贪心思路，体积越小价值越大一定最优，因此只需要让 f [ u ] [ v [ u ] ] = w [ u ] f[u][v[u]]=w[u] f[u][v[u]]=w[u]即可

#include <iostream>
#include <vector>
using namespace std;
const int N = 110;
vector<int>g[N];
int f[N][N];
int n,m;
int v[N],w[N];
void dfs(int u)
{
    f[u][v[u]]=w[u];
    for(int x : g[u])
    {
        dfs(x);
        for(int j=m;j>=v[u];j--)
            for(int k=v[u];k<=j;k++)
                f[u][j]=max(f[u][j],f[u][k]+f[x][j-k]);
    }
}
int main()
{
    int root;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int p;
        cin>>v[i]>>w[i]>>p;
        if(p==-1)root=i;
        else g[p].push_back(i);
    }
    dfs(root);
    cout<<f[root][m]<<endl;
}

2.选课—超级源点优化的树形DP

题目链接

这里的0点作为超级源点，因此计算时需要把 m + 1 m+1 m+1

#include <iostream>
#include <vector>
using namespace std;
const int N = 310;
vector<int> g[N];
int f[N][N];
int w[N];
int n,m;
void dfs(int u)
{
    f[u][1]=w[u];
    for(int v : g[u])
    {
        dfs(v);
        for(int j=m+1;j>=1;j--)
            for(int k=1;k<=j;k++)
                f[u][j]=max(f[u][j],f[u][k]+f[v][j-k]);
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int p;
        cin>>p>>w[i];
        g[p].push_back(i);
    }
    dfs(0);
    cout<<f[0][m+1]<<endl;
}

（2）边权依赖问题

1.二叉苹果树

题目链接
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 210;
int e[N],h[N],ne[N],w[N],idx=0;
int n,m;
int f[N][N];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int fa)
{
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        dfs(j,u);
        for(int j=m;j>=1;j--)
            for(int k=0;k<j;k++)
                f[u][j]=max(f[u][j],f[u][j-k-1]+f[e[i]][k]+w[i]);
    }
}
int main()
{
    memset(h, -1, sizeof h);
    cin>>n>>m;
    for(int i=1;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs(1,-1);
    cout<<f[1][m]<<endl;
}

三、换根DP

1.树的中心

题目链接
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 20010,INF=0x3f3f3f3f;
int n;
int e[N],h[N],ne[N],w[N],idx=0;
int d1[N],d2[N],p[N],up[N];
bool is_leaf[N];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int dfs_d(int u,int fa)
{
    d1[u]=d2[u]=-INF;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        int d=dfs_d(j,u)+w[i];
        if(d>=d1[u])
        {
            d2[u]=d1[u];
            d1[u]=d;
            p[u]=j;
        }
        else if(d>d2[u])d2[u]=d;
    }
    if(d1[u]==-INF)
    {
        is_leaf[u]=true;
        d1[u]=d2[u]=0;
    }
    return d1[u];
}
int dfs_u(int u,int fa)
{
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        if(p[u]==j)up[j]=max(up[u],d2[u])+w[i];
        else up[j]=max(up[u],d1[u])+w[i];
        dfs_u(j,u);
    }
    
}
int main()
{
    cin>>n;
    memset(h,-1,sizeof h);
    for(int i=1;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs_d(1,-1);
    dfs_u(1,-1);
    int res=INF;
    for(int i=1;i<=n;i++)
    {
        if(is_leaf[i])res=min(res,up[i]);
        else res=min(res,max(up[i],d1[i]));
    }
    cout<<res<<endl;
}

2.Tree

题目链接

来自大佬题解：
在这里插入图片描述

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define int long long
const int N = 2000010,mod=1e9+7;
vector<int>g[N];
int n;
int f[N]; 
int res[N];
int qmi(int a,int b)
{
	int res=1;
	while(b)
	{
		if(b&1)res=res*a%mod;
		a=a*a%mod;
		b>>=1;
	}
	return res;
}
void dfs1(int u,int fa)
{
	f[u]=1;
	for(auto j : g[u])
	{
		if(j==fa)continue;
		dfs1(j,u);
		f[u]=f[u]*(f[j]+1)%mod;
	}
}

void dfs2(int u,int fa)
{
	if(fa==-1)res[u]=f[u];
	//如果是mod的整数倍没法进行逆元运算，直接暴力求出
	else if((f[u]+1)%mod==0)
	{
		dfs1(u,-1);
		res[u]=f[u];
	}
	else 
	{
		int t=res[fa]%mod*qmi(f[u]+1,mod-2)%mod;
		res[u]=f[u]*(t+1)%mod;
	} 
	for(auto j : g[u])
	{
		if(j==fa)continue;
		dfs2(j,u);
	}
}

signed main()
{
	scanf("%lld",&n);
	for(int i=1;i<n;i++)
	{
		int a,b;
		scanf("%lld%lld",&a,&b);
		g[a].push_back(b);
		g[b].push_back(a);
	}
	dfs1(1,-1);
	dfs2(1,-1);
	for(int i=1;i<=n;i++)printf("%lld\n",res[i]);
}

3.[USACO 2018 Feb G]Directory Traversal

题目链接
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define int long long
const int N = 100010;
int n,m;
vector<int>g[N];
int w[N];
int dist[N],leaf[N];
//dist[i]表示根节点到i的距离
//leaf[i]表示i节点的子节点中叶子节点的数量
bool is_leaf[N];
int f[N];
int res,root;
//从根节点开始，叶子节点都在他的下面
void dfs1(int u)
{
	if(is_leaf[u])leaf[u]=1,f[root]+=dist[u]-1;
	for(auto v:g[u])
	{
        //这里加一是 多加一个 / 
		dist[v]=dist[u]+w[v]+1;
		dfs1(v);
		leaf[u]+=leaf[v];
	}
}
void dfs2(int u)
{
	for(auto v:g[u])
	{
        //换根dp转移方程
		f[v]=f[u]-(w[v]+1)*leaf[v]+(leaf[root]-leaf[v])*3;
		res=min(f[v],res);
		dfs2(v);
	}
}
signed main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
    	string s;cin>>s;
    	w[i]=s.size();
    	if(s=="bessie")root=i,w[root]=0;
    	cin>>m;
    	if(!m)is_leaf[i]=true;
    	for(int j=1;j<=m;j++)
    	{
    		int x;cin>>x;
    		g[i].push_back(x);
		}
	}
	dfs1(root);
	res=f[root];
    dfs2(root);
    cout<<res<<endl;
}

4.Accumulation Degree

题目链接
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define int long long
typedef pair<int,int>PII;
const int N = 400010,mod=998244353;
int f[N];
int n,m;
int e[N],ne[N],h[N],val[N],idx=0;
void add(int a,int b,int c)
{
    e[idx]=b,val[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

void dfs1(int u,int fa)
{
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int v=e[i],w=val[i];
        if(v==fa)continue;
        dfs1(v,u);
        //判断是否为叶子节点
        if(ne[h[v]]==-1)f[u]+=w;
        else f[u]+=min(f[v],w);
    }
}
void dfs2(int u,int fa)
{
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int v=e[i],w=val[i];
        if(v==fa)continue;
        f[v]+=min(w,f[u]-min(f[v],w));
        dfs2(v,u);
    }
}
void solve()
{
    memset(h,-1,sizeof h);
    memset(f,0,sizeof f);
    idx=0;
    cin>>n;
    for(int i=1;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs1(1,-1);
    dfs2(1,-1);
    int res=0;
    for(int i=1;i<=n;i++)res=max(res,f[i]);
    cout<<res<<endl;
}
signed main()
{
    int T;
    cin>>T;
    while(T--)solve();
}

四、树形状态机模型

1.删除一些边符合要求最值问题

Rinne Loves Edges

题目链接

f [ i ] : f[i]: f[i]:表示 以i为根节点到不了任何一个叶子节点的最小代价
状态转移

选择删除u和v连着的边 即 W u v W_{uv} Wuv​
选择删除使得v到不了任何一个子节点的代价，即 f [ v ] f[v] f[v]

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#define int long long
const int N = 2000010;
int w[N],e[N],ne[N],h[N],idx=0;
int n,m,s;
int f[N];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int fa)
{
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        dfs(j,u);
        f[u]+=min(f[j],w[i]);
    }
    if(ne[h[u]]==-1&&u!=s)f[u]=1e18;
}
signed main()
{
   cin>>n>>m>>s;
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs(s,-1);
    cout<<f[s]<<endl;
}

2.点相互看到的状态机模型

电话网络

题目链接

f [ i ] [ 0 ] : f[i][0]: f[i][0]: 第i个结点的父结点被选
f [ i ] [ 1 ] : f[i][1]: f[i][1]: 第i个节点本身被选
f [ i ] [ 2 ] : f[i][2]: f[i][2]: 第i个结点有一个子节点被选

状态转移
f [ u ] [ 0 ] + = m i n ( f [ v ] [ 1 ] , f [ v ] [ 2 ] ) f[u][0] += min(f[v][1],f[v][2]) f[u][0]+=min(f[v][1],f[v][2])
f [ u ] [ 1 ] + = m i n ( f [ v ] [ 1 ] , f [ v ] [ 2 ] , f [ v ] [ 0 ] ) f[u][1]+= min(f[v][1],f[v][2],f[v][0]) f[u][1]+=min(f[v][1],f[v][2],f[v][0])
f [ u ] [ 2 ] f[u][2] f[u][2]的转移较为复杂，只需要一个子节点被选即可，所以选择一个最好的子节点来选，具体看代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 20002;
int e[N],h[N],ne[N],idx=0;
int n;
int f[N][3];
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int fa)
{
    f[u][1]=1;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        dfs(j,u);
        f[u][0]+=min(f[j][1],f[j][2]);
        f[u][1]+=min({f[j][0],f[j][1],f[j][2]});
    }
    f[u][2]=0x3f3f3f3f;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==fa)continue;
        f[u][2]=min(f[u][2],f[u][0]-min(f[j][1],f[j][2])+f[j][1]);
    }
}
int main()
{
    cin>>n;
    memset(h,-1,sizeof h);
    int a,b;
    for(int i=1;i<n;i++)
    {
        cin>>a>>b;
        add(a,b);
        add(b,a);
    }
    dfs(1,-1);
    cout<<min(f[1][1],f[1][2])<<endl;
}

3.边相互看到的状态机模型

Strategic game

题目链接
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1510;
int n;
int e[N],ne[N],h[N],idx=0;
bool st[N];
int f[N][2];
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u)
{
    f[u][0]=0;
    f[u][1]=1;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        dfs(j);
        f[u][0]+=f[j][1];
        f[u][1]+=min(f[j][0],f[j][1]);
    }
}

int main()
{
    while(cin>>n)
    {
        idx=0;
        memset(h, -1, sizeof h);
        memset(f,0,sizeof f);
        memset(st,0,sizeof st);
        int id,cnt;
        for(int i=0;i<n;i++)
        {
            scanf("%d:(%d)",&id,&cnt);
            while(cnt--)
            {
                int ver;
                cin>>ver;
                add(id,ver);
                st[ver]=true;
            }
        }
        int root=0;
        while(st[root])root++;
        dfs(root);
        cout<<min(f[root][0],f[root][1])<<endl;
    }
}

4.数目划分树形DP

[HAOI2015]树上染色

题目链接

大佬题解：
在这里插入图片描述

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define int long long
typedef pair<int,int>PII;
const int N = 2030;
vector<PII>g[N];
int f[N][N];
int n,m;
int cnt[N];
int cal(int v,int w,int i,int j)
{
    return w*j*(m-j)+w*(n-m-cnt[v]+j)*(cnt[v]-j);
}
void dfs(int u,int fa)
{
    cnt[u]=1;
    for(auto [v,w]:g[u])
    {
        if(v==fa)continue;
        dfs(v,u);
        for(int i=cnt[u];i>=0;i--)
        {
            for(int j=cnt[v];j>=0;j--)
            {
                f[u][i+j]=max(f[u][i+j],f[u][i]+f[v][j]+cal(v,w,i,j));
            }
        }
        cnt[u]+=cnt[v];
    }
}
signed main()
{
    cin>>n>>m;
    for(int i=1;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a].push_back({b,c});
        g[b].push_back({a,c});
    }
    dfs(1,-1);
    cout<<f[1][m]<<endl;
}

蓝魔法师

题目链接

没想到在这里还能看到学长题解hhhh
在这里插入图片描述

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define int long long
typedef pair<int,int>PII;
const int N = 2030,mod=998244353;
vector<int>g[N];
int f[N][N];
//f[i][j]表示以i为根节点，每个连通块大小等于j的方案数
int n,m;
int cnt[N];
void dfs(int u,int fa)
{
    f[u][1]=cnt[u]=1;
    for(auto v:g[u])
    {
        if(v==fa)continue;
        dfs(v,u);
        int sum=0;
        for(int i=1;i<=min(cnt[v],m);i++)sum=(sum+f[v][i])%mod;
        for(int i=min(m,cnt[u]);i;i--)
        {
            for(int j=min(m,cnt[v]);j;j--)
            {
                if(i+j<=m)f[u][i+j]=(f[u][i+j]+f[u][i]*f[v][j])%mod;
            }
            f[u][i]=f[u][i]*sum%mod;
        }
        cnt[u]+=cnt[v];
    }
}

signed main()
{
    cin>>n>>m;
    for(int i=1;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(1,-1);
    int res=0;
    for(int i=1;i<=m;i++)(res+=f[1][i])%=mod;
    cout<<res<<endl;
}
_WAWA鱼_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
树形dp+树形结构总结
dcx2001的博客
10-18 2万+
总结       最近写了好多树形dp+树形结构的题目，这些题目变化多样能与多种算法结合，但还是有好多规律可以找的。 树形dp一般都是用子树更新父亲（即从下向上更新），那么首先应该考虑的是一个一个子树的更新父亲还是把所有子树都算完了在更新父亲？这就要因题而异了，一般来说有两种情况：1.需要把所有子树的信息都掌握之后再更新子树的就需要把所有子树都算完了在更新父亲。2.而像树上背包这样的问题就需要
树形DP整理小结
Must so
08-24 2707
树形DP: 在树上进行dp,树是递归的定义的，所以树形dp也是递归的求解，一般而言，dp[node]表示的是以node为根的子树能得到的最优解 一般而言，dp[node]需要从node的子结点进行状态转移， 树形dp又常常和背包结合起来，因为dp[node]的状态是由它的儿子转移而来， 我们常常可以将node的n个儿子看做n个物品，要如何对这n个物品抉择得到最优的dp[node]就常用到背包的思想 当然，常常dp不止node这一维，至于第二维保存什么 则根据题目来 一般都是题目给出的限制条件作为dp数组的第
一些树形DP题目の总结
qq_49620160的博客
08-08 245
一、没有上司的舞会 题目描述 Ural大学有N名职员，编号为1~N。 他们的关系就像一棵以校长为根的树，父节点就是子节点的直接上司。 每个职员有一个快乐指数，用整数 Hi 给出，其中 1≤i≤N。 现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。 在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。 输入格式 第一行一个整数N。 接下来N行，第 i 行表示 i 号职员的快乐指数Hi。 接下来N-1行，每行输入一对整数L
树形DP
weixin_44577381的博客
01-21 149
树形DP 【例题1】MZOJ1063 士兵守卫 http://61.139.95.227:82/problem.php?id=1063 题目描述 Bob特别喜欢战略游戏，但有时他不能尽快找到最优解，所以他就很伤心。现在他又有一个问题，他必须保卫一个中世纪的城市，这个城市的道路形成了一棵树。他需要在树的节点上放最少的士兵来观察所有的边。你能帮助他么？ 例如下图就只需要一个士兵放在1号节点。 输入 输...
树状DP
一步一步前进
12-25 409
题目：hdu 1011；预：int roomNumber,trooperNumber; int cost[105][105]; int dp[105[105];//dp[u][p]表示用p个兵占领以u为根节点的最大值 vector<int> adj[105]; //图main:for(i=0;i<roomNumber;i++) { cin>>bug>>brain[i]; cost[
2015人人校招笔试题汇总
04-10
左儿子右兄弟表示法是一种特殊的树形结构表示法，通常用于表示多叉树。对于给出的结构，可以通过还原左儿子右兄弟结构来确定原树，并求得前序遍历。答案选项中，只有ABFEDC符合前序遍历的顺序。 **二、填空题** 11...
NOIP相关基本资料汇总
12-28
竞赛中常见的算法包括动态规划（Dynamic Programming, DP）、贪心算法（Greedy Algorithm）、回溯法（Backtracking）、分治法（Divide and Conquer）等，这些算法在解决复杂问题时起到关键作用。 7. 普通树的遍历...
9、省选＋NOI-第九部分 博弈论_2020.08.29.pdf
11-25
* 树形 DP * 记忆化搜索 * 递推区间 DP * 序列 DP * DP 优化（不涉及斜率优化、四边形不等式等等） 搜索 * 暴搜（DFS、BFS） * 搜索的剪枝 * 启发式搜索（A\*） * 迭代加深搜索 * IDA\* 随机化搜索 博弈论 * 取...
2020_CSP-J、CSP-S注意事项-2021-10-03（C).pdf
10-03
* 第4题：最后一道题绝对是压轴题，要么是剪枝的搜索，要么是动态规划，甚至还有状压DP、树形DP之类的 学习CSP-J和CSP-S需要系统地进行相关知识的学习，坚持每周做题，集中强化训练，学习重要知识点，掌握程序思想...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5135
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 869
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 176
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 329
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 259
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 503
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 250
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法题目整合5
qq_62571233的博客
07-23 905
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
贪心加暴力枚举
wniuniu_的博客
07-24 209
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
树形DP详解：动态规划在信息学竞赛中的应用
"NOIP 提高2_树形DP" 树形动态规划（Tree Dynamic Programming，简称树形DP）是算法设计中的一个重要概念，特别是在解决与树结构相关的问题时显得尤为重要。NOIP（全国青少年信息学奥林匹克联赛）作为一项重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_WAWA鱼_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值