dp详解

最新推荐文章于 2025-06-12 09:11:08 发布
最新推荐文章于 2025-06-12 09:11:08 发布
阅读量1w 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： 暑假 疯狂dp 文章标签： dp 树形dp入门 状压dp入门 数位dp入门 dp题单
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43331783/article/details/95486986
  • 2.结语
  • Ｌｍｅｍｓｅｔ放在外面ｉｄｏｎｎｏｔ　ｋｏｎｗ　ｗｈｙ

ｄｐ详解前语

A - POJ2342:Anniversary party

树形ｄ水题。就是dp[1][0]表示不来那么子孙可以来可以不来。dp[1][１]表示来子孙不可以来，子孙的子孙可以来。所以在树上操作得到最后答案。 
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=6000+5;
int val[maxn],vis[maxn];
int dp[maxn][3];
vector<int>son[maxn];
int dfs(int i){
    dp[i][0]=0;
    dp[i][1]=val[i];
    for(int k=0;k<son[i].size();k++) {
        int sonz = son[i][k];
        dfs(sonz);
        dp[i][0] += max(dp[sonz][0], dp[sonz][1]);
        dp[i][1] += dp[sonz][0];
    }
}
int main()
{
    int n;cin>>n;
    for(int i=1;i<=n;i++)
        cin>>val[i];
    int x,y;
    for(int i=1;i<n;i++){
        cin>>x>>y;
        vis[x]++;
        son[y].push_back(x);
    }
    for(int i=1;i<=n;i++){
        if(!vis[i]){
            dfs(i);
            cout<<max(dp[i][0],dp[i][1])<<endl;
            return 0;
        }
    }
}

Ｂ - POJ1463 Strategic game

水题。某种方面就是把Ａ改一下变ｍｉｎ即可 Ｂ输入不用ｇｅｔｃｈａｒ。复杂输入用ｓｃａｎｆ 以下为ａｃ代码　一开始输入格式有问题Ｔ了改一下输入就可。 
#include<iostream>
#include <stdio.h>
#include <string.h>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=6000+5;
int val[maxn],vis[maxn];
int dp[maxn][3];
vector<int>son[maxn];
int dfs(int i){
    dp[i][0]=0;
    dp[i][1]=1;
    for(int k=0;k<son[i].size();k++) {
        int sonz = son[i][k];
        dfs(sonz);
        dp[i][0] += dp[sonz][1];
        dp[i][1] += min(dp[sonz][0],dp[sonz][1]);;
    }
}
int main()
{
    int n;
    while(cin>>n) {
        memset(dp,0,sizeof(dp));
        memset(vis,0,sizeof(vis));
        int x, y;
        for (int i = 0; i < n; i++) {
           int n1;
           scanf("%d:(%d)",&x,&n1);
            son[x].clear();
            while (n1--) {
                cin >> y;
                vis[y]++;
                son[x].push_back(y);
            }
        }
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                dfs(i);
                cout<<min(dp[i][0], dp[i][1]) << endl;
            }
        }
    }
}

错误输入


    while(cin>>n) {
        memset(dp,0,sizeof(dp));
        memset(vis,0,sizeof(vis));
        int x, y;
        for (int i = 0; i < n; i++) {
            cin >> x;
            getchar();
            getchar();
            int n1;
            cin >> n1;
            getchar();
            son[x].clear();
            while (n1--) {
                cin >> y;
                vis[y]++;
                son[x].push_back(y);
            }
        }
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                dfs(i);
                cout<<min(dp[i][0], dp[i][1]) << endl;
            }
        }
    }

正确输入

 while(cin>>n) {
        memset(dp,0,sizeof(dp));
        memset(vis,0,sizeof(vis));
        int x, y;
        for (int i = 0; i < n; i++) {
           int n1;
           scanf("%d:(%d)",&x,&n1);
            son[x].clear();
            while (n1--) {
                cin >> y;
                vis[y]++;
                son[x].push_back(y);
            }
        }
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                dfs(i);
                cout<<min(dp[i][0], dp[i][1]) << endl;
            }
        }
    }

C - POJ 2378.Tree Cutting

Ｃ有点复杂不是模板题。但是还是按照树的概念逐步更新关键在于从节点一步步更新设置更新的东西 
#include <iostream>
using namespace std;
#include <vector>
int n;const int maxn=10100;
vector<int>edge[maxn];int f[maxn],dp[maxn];
void dfs(int u,int hui){
    f[u]=1;
    int maxx=-1;
    for(int i=0;i<edge[u].size();i++){
        int v=edge[u][i];
        if(v==hui)continue;
        dfs(v,u);
        f[u]+=f[v];
        maxx=max(maxx,f[v]);
    }
    dp[u]=max(maxx,n-f[u]);
}
int main()
{
    cin>>n;
    int x,y;
    int zyx=n/2;
    for(int i=1;i<n;i++){
        cin>>x>>y;
        edge[x].push_back(y);
        edge[y].push_back(x);
    }
    dfs(1,-1);
    for(int i=1;i<=n;i++){
        if(dp[i]<=zyx){
            cout<<i<<endl;
        }
    }
}

P - hdu2196Computer

题解链接https://blog.youkuaiyun.com/shuangde800/article/details/9732825 思路正确但是代码不够简洁。Ｓ题的代码写得更好。不知道为啥上午总是思路不清理解缓慢。这个题花了一上午实在是不应该。简单来讲就是ｄｆｓ１求每个结点作为根的子树最远距离。ｄｆｓ２求答案 最远距离＝ｍａｘ（ｆ０，ｆ１）； ｆ０＝子树最远距离 ｆ１＝ｍａｘ（前层节点最大距离/第二长距离＋ｄｉｓ（ｕ，ｖ），前层节点ｆ１） 具体看题解懒得写。 
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
#include<cstring>
using namespace std;

typedef long long ll;

const int MAXN = 10010;
struct Node{
    int v, w;
};
vector<Node>edge[MAXN];
int n, m;
ll f[MAXN][2];
void dfs1(int u,int xback){
    f[u][0]=0;
    for(int i=0;i<edge[u].size();i++) {
        int v = edge[u][i].v;
        if(v==xback)continue;
        dfs1(v,u);
        f[u][0]=max(f[u][0],f[v][0]+edge[u][i].w);
    }
}
void dfs2(int u,int xback){
    int maxx=0,vx,secondmaxx=0,vs;
    int flag;
    if(u==2||u==3){
        flag=1;
    }
//    cout<<u<<" "<<<<endl;
    for(int i=0;i<edge[u].size();i++){
        int v=edge[u][i].v;
        int w=edge[u][i].w;
        if(v==xback)continue;
        int tmp=f[v][0]+w;
        if(tmp>maxx){
            //寻找最大的边长f[u][0]
            secondmaxx=maxx;vs=vx;//更新第二长secondmaxx
            maxx=tmp;vx=v;
//            if(flag)cout<<u<<maxx<<secondmaxx<<endl;
        }else if(tmp==maxx||tmp>secondmaxx){
            secondmaxx=tmp;vs=v;
//            if(flag)cout<<u<<secondmaxx<<endl;
        }

    }
    //寻找到最长边也就是f[u][0]也就是maxx最长的子节点vx=v和第二长secondmaxx
    if(u!=1) {//?
        int tmp = f[u][1];
        int v = -1;
        if (tmp > maxx) {
            secondmaxx = maxx;
            vs = vx;//更新第二长secondmaxx
            maxx = tmp;
            vx = v;
        } else if (tmp == maxx || tmp > secondmaxx) {
            secondmaxx = tmp;
            vs = v;
        }
    }
    for(int i=0;i<edge[u].size();i++){
        int v=edge[u][i].v;
        int w=edge[u][i].w;
        if(v==xback)continue;
        if(v==vx){
            f[v][1]=w+secondmaxx;
        }
        else f[v][1]=w+maxx;
        dfs2(v,u);
    }
}
int main()
{
    int n;
    while(cin>>n) {
        for (int i = 1; i <= n; i++)edge[i].clear();
        int x, y;
        for (int i = 2; i <= n; i++) {
            cin >> x >> y;
            edge[x].push_back((Node) {i, y});
            edge[i].push_back((Node) {x, y});
        }
        dfs1(1, -1);
        dfs2(1, -1);
        for (int i = 1; i <= n; i++) {
            cout << max(f[i][0], f[i][1]) << endl;
        }
    }
}

Ｓ - POJ 4003 Bob’s Race

Ｓ又麻烦又有趣的一道题。简单来讲。求每个点的最大距离（两个ｄｆｓ在ｐ中写了）然后用ｒｍｑ区间查询最值（由于这里要ｏ１所以不用线段树用ｒｍｑ）暴力求区间用查询得到响应值最后求最大值。其实就是两个ｄｆｓ＋ｒｍｑ。这里给出由ｐ过来的代码（自己写的） 
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
#include<cstring>
using namespace std;

typedef long long ll;
//#define a^j (a/2)<<j

const int MAXN = 50010;
struct Node{
    int v, w;
};
vector<Node>edge[MAXN];
int n, m;
ll f[MAXN][2];
ll d[MAXN];
int ma[MAXN][20], mi[MAXN][20];
void dfs1(int u,int xback){
    f[u][0]=0;
    for(int i=0;i<edge[u].size();i++) {
        int v = edge[u][i].v;
        if(v==xback)continue;
        dfs1(v,u);
        f[u][0]=max(f[u][0],f[v][0]+edge[u][i].w);
    }
}
void dfs2(int u,int xback){
    int maxx=0,vx,secondmaxx=0,vs;
    int flag;
    if(u==2||u==3){
        flag=1;
    }
//    cout<<u<<" "<<<<endl;
    for(int i=0;i<edge[u].size();i++){
        int v=edge[u][i].v;
        int w=edge[u][i].w;
        if(v==xback)continue;
        int tmp=f[v][0]+w;
        if(tmp>maxx){
            //寻找最大的边长f[u][0]
            secondmaxx=maxx;vs=vx;//更新第二长secondmaxx
            maxx=tmp;vx=v;
//            if(flag)cout<<u<<maxx<<secondmaxx<<endl;
        }else if(tmp==maxx||tmp>secondmaxx){
            secondmaxx=tmp;vs=v;
//            if(flag)cout<<u<<secondmaxx<<endl;
        }

    }
    //寻找到最长边也就是f[u][0]也就是maxx最长的子节点vx=v和第二长secondmaxx
    if(u!=1) {//?
        int tmp = f[u][1];
        int v = -1;
        if (tmp > maxx) {
            secondmaxx = maxx;
            vs = vx;//更新第二长secondmaxx
            maxx = tmp;
            vx = v;
        } else if (tmp == maxx || tmp > secondmaxx) {
            secondmaxx = tmp;
            vs = v;
        }
    }
    for(int i=0;i<edge[u].size();i++){
        int v=edge[u][i].v;
        int w=edge[u][i].w;
        if(v==xback)continue;
        if(v==vx){
            f[v][1]=w+secondmaxx;
        }
        else f[v][1]=w+maxx;
        dfs2(v,u);
    }
}
int logg[MAXN];
int getlog(){
    for(int k=1;k<=n;k++) {
        logg[k]=0;
        while((1<<(logg[k]+1))<=k)logg[k]++;
//        int l = 2;
//        while (l <= k ) {
//            l *= 2;
//            logg[k]++;
//        }cout<<k<<logg[k]<<endl;
    }
}
void rmq_init(){
    for(int i=1;i<=n;i++){
        ma[i][0]=mi[i][0]=d[i];
    }
    for(int j=1;(1<<j)<=n;j++)
        for(int i=1;i+(1<<j)-1<=n;i++) {
            ma[i][j] = max(ma[i][j - 1], ma[i + (1<<(j - 1))][j - 1]);
            mi[i][j] = min(mi[i][j - 1], mi[i + (1<< (j - 1))][j - 1]);
        }
    getlog();
}
int rmq(int l,int r){
    int k=logg[r-l+1];
//    cout<<max(ma[l][k],ma[r-(2^k)+1][k])-min(mi[l][k],mi[r-(2^k)+1][k])<<endl;
    return max(ma[l][k],ma[r-(1 << k)+1][k])-min(mi[l][k],mi[r-(1 << k)+1][k]);
}
int main() {
    int query, Q;
    while (cin >> n >> query&&!(!n&&!query)) {
        for (int i = 1; i <= n; i++)edge[i].clear();
        int x, y, z;
        for (int i = 1; i < n; i++) {
            cin >> x >> y>>z;
            edge[x].push_back((Node) {y, z});
            edge[y].push_back((Node) {x, z});
        }
        dfs1(1, -1);
        dfs2(1, -1);
        for (int i = 1; i <= n; i++) {
            d[i] = max(f[i][0], f[i][1]);
        }
        rmq_init();

        while (query--) {
            cin >> Q;
            int l = 1, maxx = 0;
            for (int i = 1; i <= n; i++) {
                while (l < i && rmq(l, i) > Q)l++;
                maxx = max(maxx, i-l+ 1);
            }
            cout << maxx << endl;
        }
    }
}

别人的题解（这个写的真的优秀。可以直接去写ｐ比原来的ｐ的方法简单）https://www.cnblogs.com/gj-Acit/p/4661024.html

#pragma comment(linker, "/STACK:1677721600")
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)

template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

//typedef __int64 LL;
typedef long long LL;
const int MAXN = 50000 + 100;
const int MAXM = 110000;
const double eps = 1e-8;
LL MOD = 1000000007;

struct Node {
    int v, s;
    Node(int _v = 0, int _s = 0) {
        v = _v; s = _s;
    }
};

vector<Node>G[MAXN];
int mx[MAXN], se[MAXN], d[MAXN], idx[MAXN];
int ma[MAXN][20], mi[MAXN][20];
int n, u, v, w;
int m, Q;

void init(int n) {
    rep (i, 0, n) G[i].clear();
    mem0(mx); mem0(se);
}

void dfs1(int u, int fa) {
    mx[u] = se[u] = 0;
    int sz = G[u].size();
    rep (i, 0, sz - 1) {
        int v = G[u][i].v;
        if(v == fa) continue;
        dfs1(v, u);
        int len = G[u][i].s + mx[v];
        if(len > mx[u]) se[u] = mx[u], mx[u] = len;
        else if(len > se[u]) se[u] = len;
    }
}

void dfs2(int u, int fa, int dis) {
    d[u] = max(dis, max(mx[u], se[u]));
    int sz = G[u].size();
    rep (i, 0, sz - 1) {
        int v = G[u][i].v, len = G[u][i].s;
        if(v == fa) continue;
        if(len + mx[v] == mx[u])
            dfs2(v, u, max(dis, se[u]) + len);
        else
            dfs2(v, u, max(dis, mx[u]) + len);
    }
}

void rmq_init(int n) {
    rep (i, 1, n) ma[i][0] = mi[i][0] = d[i];
    for(int j = 1; (1<<j) <= n; j ++) {
        for(int i = 1; i + (1<<j) - 1 <= n; i ++) {
            ma[i][j] = max(ma[i][j - 1], ma[i + (1 << (j - 1))][j - 1]);
            mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);
        }
    }
    rep (len, 1, n) {
        idx[len] = 0;
        while((1 << (idx[len] + 1)) <= len) idx[len] ++;
    }
}

int rmq(int l, int r) {
    int k = idx[r - l + 1];
    return max(ma[l][k], ma[r - (1 << k) + 1][k]) - min(mi[l][k], mi[r - (1 << k) + 1][k]);
}

int main()
{
//    FIN;
    while(~scanf("%d %d", &n, &m) && n) {
        init(n);
        rep (i, 1, n - 1) {
            scanf("%d %d %d", &u, &v, &w);
            G[u].push_back(Node(v, w));
            G[v].push_back(Node(u, w));
        }

        //计算每个点到叶子节点的最远距离
        dfs1(1, -1);
        dfs2(1, -1, 0);

        //计算答案
        rmq_init(n);
        while(m --) {
            scanf("%d", &Q);
            int l = 1, ans = 0;
            rep (i, 1, n) {
                while(l < i && rmq(l, i) > Q) l ++;
                ans = max(ans, i - l + 1);
            }
            cout << ans << endl;
        }
    }
    return 0;
}

树形ｄｐ总结https://blog.youkuaiyun.com/qq_39304630/article/details/81836024

状压

更多题目移步状压专题https://blog.youkuaiyun.com/weixin_43331783/article/details/96566758

G -POJ - 2411Mondriaan's Dream

https://www.cnblogs.com/scau20110726/archive/2013/02/27/2935256.html 思路有点难想想出来就基本模拟了代码还好不算难写但最近真的疯狂写ｂｕｇ我也是醉了。周天这道题要再写一遍不要看题解自己改ｂｕｇ然后之前的ｂｕｇ是分析情况漏掉了ｊ＝＝ｍ－１下次注意就这样。 
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define  mod 100000000
int n,m;
long long dp[15][1<<12];
bool firhang(int sta){
    for(int j=0;j<m;){
        if(sta&(1<<j)){
            if(j==m-1)return false;
            if(sta&(1<<(j+1))){
                j+=2;
            }
            else return false;
        }
        else j++;
    }
    return true;
}

//初始航｛
//遍历列列举情况
//｝
bool check(int now,int pre){
    for(int j=0;j<m;) {
        if (now & (1 << j)) {
            if ((pre & (1 << j))&&j!=m-1&& (pre & (1 << (j + 1))) && (now & (1 << (j + 1)))) {
                j += 2;
            } else if (!(pre & (1 << j)))j++;
            else return false;
        } else {
            if (pre & (1 << j))j++;
            else return false;
        }
    }
    return true;
}

//检查｛
//遍历列列举情况
//｝
void solve(){
    int li=1<<m;
    memset(dp,0, sizeof(dp));
for(int s=0;s<li;s++){
    if(firhang(s))
    dp[1][s]=1;
}
for(int i=2;i<=n;i++){
   for(int j=0;j<li;j++)
       for(int k=0;k<li;k++){
           if(check(j,k))
               dp[i][j]+=dp[i-1][k];
       }
}
cout<<dp[n][li-1]<<endl;
//遍历２－ｎ行遍历ｊｋ行状态。检查增值。
//输出
}
int main()
{
    while(cin>>n>>m&&(n||m)){
        if((n&1)&&(m&1)){
            cout<<0<<endl;
            continue;
        }
        if(n<m){
            swap(n,m);
        }
        solve();
    }
    return 0;
}

H - Travelling HDU - 3001

https://blog.youkuaiyun.com/u014634338/article/details/50015825 ＨＴＳＰ问题有点难。感觉理解不是很透彻。独立不看题解再写一遍。 伪代码：（建议想清楚思路在看，否则只是会打没有） １设置函数求状态的各个位置数和的１２个数（three[],sum)返回个数。 ２初始化ｄｐ、ｍｐ ３．设置函数（数组）求３的ｋ次方（如果是二进制就２的） ４．建图（这里的点是１－ｎ。两点之间可能有多个路径求最小） ５．重点：枚举状态｛ 　　　　　　　枚举终点｛ 　　　　　　　如果这个点有｛ 　　　　　　　１如果是直接链接１（０）的点 　　　　　　　２如果是不可大的 　　　　　　　３当为最终状态（１１１１１） 　　　　　　　４枚举其他点（是他下一个点不是前一个！！！之前该ｂｕｇ改了好久）建立新状态（分有没有来过求最小值） 　　　　　　　｝ 　　　　　　　｝ 　　　｝ 　　　输出最小值（判断是否可达不可达为－１） 以下为代码 
#include <cstring>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <queue>

using namespace std;
int mp[12][12],dp[12][60000];
int n,m;
const int maxn=0x3f3f3f3f;

int arr(int three[],int sum){
    int k=0;
    for(int i=0;i<n;i++){
        three[i]=sum%3;
        sum/=3;
        if(three[i])k++;
    }
//    cout<<sum<<k<<endl;
    return k;
}
void init(int li){
    for(int i=0;i<n;i++){
        for(int j=0;j<li;j++){
            dp[i][j]=-1;
        }
        for(int j=0;j<n;j++){
            mp[i][j]=-1;
        }
    }
}

int main()
{
    int a,b,c,in[12],three[12];
    in[0]=1;
    for(int i=1; i<=10; i++)in[i]=in[i-1]*3;
    while(~scanf("%d%d",&n,&m))
    {
        init(in[n]);
        for(int i=0;i<m;i++){
            cin>>a>>b>>c;
            a--;b--;
            if(mp[a][b]==-1){
                mp[a][b]=mp[b][a]=c;
            }
            else{
                mp[a][b]=mp[b][a]=min(c,mp[a][b]);
            }
        }
        int li=in[n],flag=-1,minn=maxn;
//        cout<<li<<endl;
        for(int s=1/**/;s<li;s++){
//            cout<<s<<"/"<<endl;
            int k=arr(three,s);
            for(int po=0;po<n;po++){
                if(three[po]){
                    if(k==1){dp[po][s]=0;}
                    if(dp[po][s]==-1)continue;
                    if(k==n){flag=0;minn=min(minn,dp[po][s]);}
                    for(int npo=0;npo<n;npo++){
                        if(npo!=po&&three[npo]<2&&mp[po][npo]!=-1){
                            int news=s+in[npo];
                            if(dp[npo][news]==-1)dp[npo][news]=dp[po][s]+mp[po][npo];
                            else dp[npo][news]=min(dp[npo][news],dp[po][s]+mp[po][npo]);
//                            cout<<po<<" "<<news<<" "<<dp[po][news]<<endl;
                        }
                    }
                }
            }
        }
        if(!flag)cout<<minn<<endl;
        else cout<<flag<<endl;
    }
    return 0;
}

https://blog.youkuaiyun.com/txgANG/article/details/72552055

【算法竞赛学习笔记】DP入门-超有用的DP详解
SC_Linno的博客
10-31 837
title : DP入门 tags : ACM,动态规划 date : 2021-10-31 author : Linno DP入门 简介 动态规划（Dynamic programming，简称DP） 把复杂的问题分成若干个子问题进行求解，最终递推至整个大问题的答案。 适用范围 ①满足最优子结构：不管过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。 ②无后效性：以前各阶段的状态无法直接影响它未来的决策。 ③子问题重叠性：由于DP实现过程中，需要不断储存各种状态，空间复杂度.
动态规划之区间DP详解
晨的博客
09-08 1460
区间DP
dp讲解
housansan的专栏
07-12 1579
因为我查看的没有地址所以不知道原创地址 1，什么是动态规划（DP）？ 非常重要！，不要认为概念不重要，理解的深刻，你才知道对于什么样的问题去考虑有没有动态规划的方法，以及如何去使用动态规划。 1）动态规划是运筹学中用于求解决策过程中的最优化数学方法。当然，我们在这里关注的是作为一种算法设计技术，作为一种使用多阶段决策过程最优的通用方法。它是应用数学中用于解决某类最优化问题的重要工具。
DPVS负载均衡器使用教程：从基础到高级配置
gitblog_00250的博客
06-12 417
DPVS负载均衡器使用教程：从基础到高级配置 前言 DPVS是一款基于DPDK的高性能负载均衡器，由某知名视频平台团队开发并开源。本文将详细介绍DPVS的核心概念、多种工作模式配置方法以及高级功能使用指南，帮助读者全面掌握这一强大工具。 核心概念解析 网络拓扑模式 DPVS支持两种基本网络拓扑结构： 双臂模式(Two-arm)：负载均衡器位于客户端和服务器之间，使用两个独立的网络接口分别连接客...
DP 详解
George110915的博客
09-09 5944
DP 问题在 OIer 中很受欢迎，因为每个 DP 问题在某种意义上都是原创的，你必须努力思考其状态和状态转移方程才能为其发明解决方案。由于动态规划如此受欢迎，它可能是算法竞赛中最重要的掌握方法。DP（Dynamic programming，全称动态规划），是一种基于分治，将原问题分解为简单子问题求解复杂问题的方法。动态规划的耗时往往远少于朴素（爆搜）解法。很简单的名字，即为使用空间的代价来确保不会超时。分类讨论就是分类 --> 讨论！
【算法之动态规划（一）】动态规划（DP）详解
热门推荐
cangchen的专栏
04-14 4万+
一、基本概念 动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，提出了著名的最优化原理(principle of optimality)，把多阶段过程
DP（动态规划）入门基础详解
qq_44341728的博客
05-01 3149
DP总结 ps：学了近两个月的DP，是时候总结一波了… DP基本概要： 动态规划算法把原问题视作若干个重叠子问题的逐层递进,每一个子问题的求解过程都构成一个“阶段”。在完成前一个阶段的计算后,动态规划才会执行下一阶段的计算。 无后效性 ： 为了保证这些计算能够按顺序，不重复进行，动态规划要求当前阶段不会对前面的阶段产生影响的基本条件。 最优子结构性质：大多数情况下，动态规划是用来求解最优化问题。此...
线性DP详解，有例题详解，有练习题
10-20
【线性动态规划详解】 线性动态规划（Linear Dynamic Programming, 线性DP）是动态规划的一个子领域，主要用于解决具有线性关系的状态转移问题。这类问题的特点是状态之间的关系呈线性，即每个状态通常只依赖于少数...
【动态规划】数学期望/概率DP/期望DP详解
繁凡さん的博客
02-12 1万+
期望DP概述规律全概率公式例题1.UVA11021 Tribles麻球繁衍2.算概率（简单，数论） 概述 一般来说，概率DP找到正确的状态定义后，转移是比较容易想到的。但状态一定是“可数”的，把有范围的整数作为数组下标。事实上，将问题直接作为状态是最好的。如问“n人做X事的期望次数”，则设计状态为f[i]表示i个人做完事的期望。转移一般是递推，即从上一个状态转移得（填表）或转移向下一个状态（刷表）...
动态规划DP详解：线性DP与实例解析
"线性DP详解，包括例题和练习，适用于C++编程" 线性动态规划（DP）是一种解决特定类型问题的优化技术，主要应用于计算机科学，特别是在算法设计中。线性DP的特点在于其状态之间的关系呈线性，即状态通常是基于一个...
动态规划dp详解（破解之道，就在其中）
wzxtsl的博客
03-20 2936
动态规划（英语：Dynamic programming，简称 DP），是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。简单来说，动态规划其实就是，给定一个问题，我们把它拆成一个个子问题，直到子问题可以直接解决。然后呢，把子问题答案保存起来，以减少重复计算。再根据子问题答案反推，得出原问题解的一种方法。
区间dp详解（入门到进阶）
xiange的自闭路
08-30 1740
目录   前言： 初级版：51Nod - 1021 石子合并（区间dp，时间复杂度） 思路： 状态转移方程： AC代码： 中级版：HDU - 3506 Monkey Party（四边形不等式优化，时间复杂度） 思路： 四边形不等式： 状态转移方程： AC代码： 高级版：HYSBZ - 3229 石子合并（GarsiaWachs算法优化，时间复杂度常数小） 思路： AC代...
动态规划dp详解
qq_35710556的博客
08-03 1871
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。 分类 编辑 动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。 举例： 线性动规：拦截导弹(最长非递增子序列)，合唱队形，挖地雷，建学校，剑客决斗等； 区域动规：石子合并， 加分二叉树，统计单词个数，炮兵
状压DP入门详解
稚始稚终的博客
09-04 4197
（最近做到了状压dp的题目，自己不会，于是学习了一手） 1.位运算（基础） 名称 符号 运算法则 举例 按位与 a&b 两者同时为1则为1，否则为0 00101&11100=00100 按位或 a l b 有1为1，无1为0 00101 l 11100=11101 按位异或 a^b 相同为0，不同为1 00101^11100=11001 按位取反 ~a 是1为0，是0为1 ~00101=11010 左移 a<<b 把对应的二进制数左移b位 0010
深度干货 | 万字长文详解数位dp，超详细题集汇总
qq_45832461的博客
03-11 997
史上最通俗易懂，最简单，最全面的数位dp习题集，帮你扫清各种数位dp难题，背诵一套模板秒杀各种数位dp！！！
⭐️动态规划（Dynamic programming）详解
Python老吕的博客
03-30 5746
动态规划（Dynamic Programming，简称DP）是一种广泛应用于数学、计算机科学和经济学等领域的方法论。其核心思想是通过将复杂问题分解为相对简单的子问题，并存储子问题的解以避免冗余计算，从而显著提高计算效率。动态规划作为运筹学的一个分支，专注于解决决策过程的最优化问题。20世纪50年代初，美国数学家贝尔曼（R. Bellman）等人在研究多阶段决策过程的优化问题时，提出了著名的最优化原理，并基于此创立了动态规划。
dp再回顾之思路分析，及小知识点总结
zhhx2001的博客
06-13 1059
dp题的步骤 1、构造问题所对应的过程。 2、思考过程的最后一个步骤（或一个），看看有哪些选择情况。 3、根据这个选择情况化为子问题 4、分析边界，考虑边界的各种处理方式 5、写出状态转移方程 要敢想，敢突破思维的束缚！！！！！
算法精品讲解(2)——DP问题入门（适合零基础者，一看就会）
jxwd的博客
12-07 2万+
目录前言DP问题它是什么（了解）从中学的例题谈起再来说一下，DP问题的核心思想（理解）DP问题的解决方法先说方法论：再说具体的例子例一：例二：例三：DP和搜索的关系结语DP入门介绍：先画个饼吧哈哈。看完之后，你也可以。如下，是我们本节将要讲述的内容。我们将结合着LeetCode、洛谷和CodeForce上面的一些习题来作为我们的参考。难度循序渐进，直到大于等于LeetCode Hard。文章首发于wx公众h【自学编程村】 我们下面就进入正文。大名鼎鼎的DP问题，实际上就是Dynamic programmin
Android DP解析
zhyx小妖
07-13 701
Android DP解析 之前面试被问到dp是比例吗？那么dp是什么呢？明知dp不是比例，却不知如何回答，一时语塞…想到用了这么久的dp，却对它完全不了解，惭愧。 基本概念 名词概念 名称 解释 px 像素点，一个像素点为1px dp 即dip，像素密度 sp 同dp，但是可以根据系统字体偏好缩放 dpi 每英寸的像素数，也叫...
换根dp详解
最新发布
08-12
<think>首先，用户要求我回答关于“换根DP详解”的问题，这是树形动态规划中的一种技巧。我需要确保我的回答结构清晰，逐步解决问题，并尽量真实可靠。 从系统级指令： - 所有行内数学表达式必须用$...$格式。 - 独立公式用$$...$$格式，单独成段。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 引用的段落末尾添加引用标识，如[^1]。 用户提供了参考站内引用，但指出这些仅供参考，不是用户真正的需求。用户意图是了解“换根DP”这一算法概念，可能与树形DP相关。参考引用包括： - 引用[1]: 关于树形DP和换根DP的目录。 - 引用[2]: 关于区间DP的内容。 用户上一次的问题可能是关于换根DP的，所以我需要基于这个来回答。用户说：“我想用户意图是了解'换根dp'这一算法概念的详细内容，可能是学习动态规划中的树形DP相关知识。” 所以，我的回答应该聚焦在换根DP的详解上。 结构化回答： - 介绍换根DP是什么。 - 解释其原理和应用场景。 - 描述实现步骤。 - 提供示例。 - 讨论难点和优化。 - 最后，生成相关问题。 确保使用中文。 关键内容： - 换根DP（Root Changing DP）是树形动态规划的一种优化技巧，用于解决树结构上的问题，其中我们需要计算每个节点作为根时的某些值。 - 原理：通过一次DFS（深度优先搜索）计算一个根节点的值，然后通过另一个DFS（或类似方法）更新其他节点的值，利用树的结构和父子关系。 - 应用场景：当问题要求对树中每个节点作为根时计算某个度量，如子树大小、距离和等。 - 实现步骤： 1. 选择初始根（通常任意选择）。 2. 进行一次DFS（后序遍历）计算以该根为根的子树的值。 3. 进行第二次DFS（前序遍历或自顶向下）更新其他节点作为根时的值，使用父子关系传递信息。 - 示例：经典问题是计算树中每个节点到其他所有节点的距离之和。 - 难点：处理状态转移时，需要正确更新父节点和子节点的关系。 - 优化：使用记忆化或优化状态转移。 对于数学表达式： - 如果有公式，如距离计算公式，用LaTeX。 - 例如，节点u到v的距离，或子树大小。 - 独立公式用$$...$$，行内用$...$。 生成相关问题：在回答末尾，添加“相关问题”部分，列出几个相关问题。 引用：由于用户提供了参考引用，我可以在相关内容后添加引用标识。但用户说“上述引用仅供参考”，所以我需要谨慎使用。引用[1]提到“换根DP详解”，所以我可以在解释时引用它。 例如： - “换根DP的原理如引用[1]所述...” 然后添加[^1]。 但用户说“并不是用户真正的需求”，所以我应该基于知识回答，而不是依赖引用。 回答结构： 1. **引言**：定义换根DP和其重要性。 2. **原理**：解释换根DP如何工作。 3. **应用场景**：给出适用的问题类型。 4. **实现步骤**：详细步骤，可能包括伪代码或代码示例。 5. **示例**：具体例子，如计算每个节点的距离和。 6. **难点与优化**：讨论常见问题和如何优化。 7. **总结**：简要回顾。 8. **相关问题**：生成相关问题。 代码示例：如果需要，提供代码。用户示例中有Python代码，所以我可以用Python或C++（因为引用[2]提到C++）。 用户引用[1]有目录，包括“2.1 换根 DP 的原理”等，所以我应该覆盖这些点。 现在，草拟内容： - **什么是换根DP？** 换根DP是树形动态规划的一种技巧，用于高效计算树中每个节点作为根时的某些属性。它通过两次DFS遍历实现：第一次计算以某个节点为根的值，第二次“换根”更新其他节点。 - **原理** 换根DP的核心是状态转移。假设我们有一个函数$f(u)$表示以u为根时的值。第一次DFS计算$f(root)$。然后，在第二次DFS中，当我们从父节点p移动到子节点u时，我们更新$f(u)$基于$f(p)$和移除u子树后剩余树的信息。 例如，对于距离和问题： - 让$distSum(u)$表示以u为根时，所有节点到u的距离之和。 - 第一次DFS：计算以根节点为根的$distSum$和子树大小$size(u)$。 - 状态转移：当换根到子节点u时，$distSum(u) = distSum(p) - size(u) + (n - size(u))$，其中n是总节点数。因为移动到u后，u子树内的节点距离减少1，子树外的增加1。 数学上： $$distSum(u) = distSum(p) - size(u) + (n - size(u))$$ - **应用场景** 适用于需要为每个节点计算基于整个树的全局信息的问题，如： - 每个节点的距离和。 - 每个节点的子树最大深度或直径。 - 在树中找中心节点。 - **实现步骤** 1. 选择任意节点作为根（如节点0）。 2. 第一次DFS（后序）：计算子树大小$size[u]$和以u为根的子树距离和（或其他值）。 3. 第二次DFS（前序）：更新每个节点的全局值，使用父节点的值。 4. 输出结果。 伪代码： ``` def dfs1(u, parent): size[u] = 1 distSum[u] = 0 # 对于距离和问题 for v in children of u: if v != parent: dfs1(v, u) size[u] += size[v] distSum[u] += distSum[v] + size[v] # 因为每个v子树节点距离增加1 def dfs2(u, parent): for v in children of u: if v != parent: # 更新v的distSum：从u换根到v distSum[v] = distSum[u] - size[v] + (n - size[v]) dfs2(v, u) ``` - **示例** 考虑一个简单树：3个节点，1-2-3。 - 以1为根：计算size和distSum。 - size[1]=3, size[2]=2, size[3]=1 - distSum[1]：1到2距离1，1到3距离2（通过2），总和1+2=3？等等，需要计算。 标准计算：在dfs1中，distSum[u] += distSum[v] + size[v]，因为每个v子树节点贡献distSum[v]加上它们到u的距离（由于u到v的边）。 - 从叶子开始：节点3：size=1, distSum=0（没有子节点）。 - 节点2：size=2（包括自己和3），distSum = distSum[3] + size[3] = 0 + 1 = 1（因为3到2距离1）。 - 节点1：size=3, distSum = distSum[2] + size[2] = 1 + 2 = 3（2到1距离1，3到1距离2）。 - 现在换根：从1到2。 - distSum[2] = distSum[1] - size[2] + (n - size[2]) = 3 - 2 + (3-2) = 3 - 2 + 1 = 2 - 验证：以2为根，2到1距离1，2到3距离1，总和2，正确。 - 到节点3：distSum[3] = distSum[2] - size[3] + (n - size[3]) = 2 - 1 + (3-1) = 2-1+2=3？但以3为根，3到1距离2，3到2距离1，总和3，正确。 - **难点与优化** - 难点：正确推导状态转移方程；处理树的结构；避免重复计算。 - 优化：使用记忆化；对于复杂问题，可能需要存储额外状态；时间复杂度O(n)，因为两次DFS。 - **总结** 换根DP是强大的树形DP技巧，能高效解决每个节点为根的问题。 - **相关问题** 生成几个相关问题： 1. 如何推导换根DP的状态转移方程？ 2. 换根DP在哪些实际应用中常见？ 3. 如何处理换根DP中的边界情况？ 4. 换根DP与其他树形DP技巧的区别是什么？ 引用：在适当的地方添加[^1]，例如当提到原理时。 确保LaTeX正确：例如，行内用$distSum(u)$，独立公式用$$...$$。 代码块：用```包围，如示例。 最后，输出相关问题部分。</think>### 换根DP详解：树形动态规划中的换根技巧 换根DP（Root Changing Dynamic Programming）是树形动态规划的一种高级技巧，用于高效解决树结构中“以每个节点为根计算全局属性”的问题。它通过两次深度优先搜索（DFS）实现：第一次计算以某个根节点为基准的值，第二次通过“换根”更新其他节点的值。以下内容将逐步详解其原理、应用、实现及优化，确保回答真实可靠，基于经典算法知识[^1]。 --- #### 1. **什么是换根DP？** 换根DP是树形DP的扩展，核心思想是通过动态调整根节点来复用子树计算结果，避免对每个节点单独进行完整的DFS遍历。其优势在于将时间复杂度从$O(n^2)$优化到$O(n)$（n为节点数），适用于需要为每个节点计算全局指标的问题，如距离和、子树大小等[^1]。 - **关键特点**： - **动态根切换**：基于一个根节点的计算结果，推导其他节点为根时的值。 - **状态复用**：利用树的结构特性（如父子关系），避免重复计算。 - **高效性**：仅需两次DFS遍历，时间复杂度$O(n)$，空间复杂度$O(n)$。 #### 2. **换根DP的原理** 换根DP的原理基于状态转移方程，利用父节点与子节点的关系更新值。核心步骤如下： 1. **初始根计算**：选择一个任意节点（如节点0）作为根，通过DFS（后序遍历）计算以它为根的子树状态。 2. **换根更新**：通过第二次DFS（前序遍历），从父节点向子节点传递信息，更新以子节点为根时的状态。 数学上，状态转移依赖父子节点的差值。以经典问题“计算每个节点到其他所有节点的距离之和”（$distSum(u)$）为例： - 定义$size(u)$为以u为根的子树节点数（包括u自身）。 - 第一次DFS后，得到根节点$p$的$distSum(p)$。 - 当换根到子节点$u$时，状态转移方程为： $$distSum(u) = distSum(p) - size(u) + (n - size(u))$$ 其中$n$是总节点数。解释：换根后，$u$子树内的节点距离减少1（贡献$-size(u)$），子树外的节点距离增加1（贡献$+(n - size(u))$）[^1]。 #### 3. **适用场景** 换根DP适用于以下问题特征： - **全局节点计算**：需要为树中每个节点独立计算一个全局属性。 - **子树依赖**：属性计算依赖于子树结构。 - **常见问题类型**： - 每个节点的距离和（如上述$distSum$问题）。 - 每个节点的子树直径或最大深度。 - 树的重心或中心节点查找。 - 网络优化中的节点影响度计算。 不适用场景：问题仅需单一根节点结果，或属性无子树依赖时，换根DP可能过度复杂。 #### 4. **实现步骤与示例** 以下以“计算每个节点的距离和”为例，详细说明实现步骤（使用Python伪代码）。假设树以邻接表存储，节点数$n$。 ##### **步骤详解**： 1. **初始化**： - 选择任意根节点（如节点0）。 - 定义数组：$size[\ ]$存储子树大小，$distSum[\ ]$存储距离和，$parent[\ ]$存储父节点信息。 2. **第一次DFS（后序遍历：自底向上计算子树状态）**： - 计算以当前节点$u$为根的$size[u]$和$distSum[u]$。 - 状态更新：$distSum[u] = \sum_{v \in \text{children}} (distSum[v] + size[v])$，因为每个子节点$v$的子树节点到$u$的距离需额外加上边权（这里假设边权为1）。 3. **第二次DFS（前序遍历：自顶向下换根更新）**： - 从根节点开始，对每个子节点$u$，应用状态转移方程更新$distSum[u]$。 - 方程：$distSum[u] = distSum[\text{parent}] - size[u] + (n - size[u])$。 4. **输出结果**：遍历$distSum[\ ]$数组，得到每个节点为根时的距离和。 ##### **代码示例**： ```python def dfs1(u, parent, graph, size, distSum): size[u] = 1 # 初始化子树大小（包括自身） distSum[u] = 0 # 初始化距离和 for v in graph[u]: if v == parent: continue dfs1(v, u, graph, size, distSum) # 递归处理子节点 size[u] += size[v] # 累加子树大小 distSum[u] += distSum[v] + size[v] # 更新距离和：子节点贡献 + 子节点子树大小（因距离+1） def dfs2(u, parent, graph, size, distSum, n): for v in graph[u]: if v == parent: continue # 换根更新：从父节点u到子节点v distSum[v] = distSum[u] - size[v] + (n - size[v]) dfs2(v, u, graph, size, distSum, n) # 递归更新子节点 def main(): n = 5 # 假设节点数 graph = [[1, 2], [0, 3, 4], [0], [1], [1]] # 邻接表表示的树：0-1-3, 0-1-4, 0-2 size = [0] * n distSum = [0] * n # 第一次DFS：以0为根计算 dfs1(0, -1, graph, size, distSum) # 第二次DFS：换根更新所有节点 dfs2(0, -1, graph, size, distSum, n) print("每个节点的距离和:", distSum) # 输出如: [distSum[0], distSum[1], ...] if __name__ == "__main__": main() ``` ##### **示例解析**： 考虑树：节点0连接1和2，节点1连接3和4（结构：0-1-3, 0-1-4, 0-2）。 - **第一次DFS后（以0为根）**： - $size[0]=5$（全树），$size[1]=3$（子树1,3,4），$size[3]=1$等。 - $distSum[0]$计算：子节点1贡献$distSum[1] + size[1]$，子节点2贡献$distSum[2] + size[2]$。 - **换根到节点1后**： - $distSum[1] = distSum[0] - size[1] + (n - size[1])$。 - 例如，若$distSum[0]=6$, $size[1]=3$, $n=5$，则$distSum[1]=6-3+(5-3)=5$。 验证：以1为根，节点到1的距离和应为5（如距离：1到0=1, 1到3=1, 1到4=1, 1到2=2，总和5），正确[^1]。 #### 5. **难点与优化技巧** - **难点**： - **状态转移推导**：需精确建模父子关系（如上述距离和方程）。 - **边界处理**：叶节点或单节点树需特殊处理（代码中通过$size[u]=1$初始化解决）。 - **树结构变化**：若树非连通或有权重，需调整状态方程。 - **优化方法**： 1. **记忆化搜索**：存储中间结果，避免重复计算（如$size[\ ]$数组）。 2. **空间优化**：重用数组减少内存（如$distSum[\ ]$直接覆盖）。 3. **方程简化**：对特定问题推导更高效方程（如子树直径问题用$maxDepth$替代）。 4. **结合其他算法**：与BFS或线段树结合处理动态树[^2]。 #### 6. **总结** 换根DP通过两次DFS高效解决树形问题，核心在于状态转移方程的推导和父子关系利用。其$O(n)$时间复杂度优于朴素方法，适用于竞赛和实际场景（如网络路由优化）。掌握换根DP需熟练树形DP基础，并多练习经典问题（如[Codeforces](https://codeforces.com)题目）[^1]。 --- ### 相关问题 1. 如何推导换根DP的状态转移方程？ 2. 换根DP在树的重心查找中如何应用？ 3. 如何处理换根DP中的带权重树问题？ 4. 换根DP与区间DP（如石子合并）的主要区别是什么？[^2] [^1]: 集训DAY8之树形 DP与换根DP。深入浅出树形 DP 与换根 DP 目录 树形 DP 基础 1.1 什么是树形 DP1.2 树形 DP 的应用场景1.3 树形 DP 的实现步骤与示例1.4 树形 DP 的优化技巧 换根 DP 详解 2.1 换根 DP 的原理2.2 换根 DP 的适用情况2.3 换根 DP 的实现步骤与示例2.4 换根 DP 的难点与解决方法 树形 DP 与换根 DP 的联系与区别进阶应用与实战分析 4.1 复杂树形结构下的 DP 应用4.2 结合其他算法的综合问题4.3 实战题目解析 总结与拓展 一、树形 DP 基础 1.1 什么是树形 DP。 [^2]: 区间动态规划 (Interval DP) 详解：从原理到实战（C++实现）一、区间DP基础概念1.1 什么是区间DP1.2 适用问题特征 二、区间DP的通用解法框架2.1 状态定义2.2 状态转移方程2.3 初始化 三、经典例题详解（附C++代码）3.1 石子合并（最小代价）3.2 最长回文子序列 (LPS) 四、区间DP的四种常见模型4.1 链式区间DP（石子合并类）4.2 环形区间DP4.3 记录决策点（输出具体方案）4.4 高维区间DP 五、四边形不等式优化（Knuth优化）5.1 适用条件5.2 优化实现 六、实战训练（附解法）6.1 括号匹配（最大匹配数）6.2 切木棍（最优切割成本） 七、区间DP技巧总结八、高频面试题精选九、区间DP扩展应用9.1 树形区间DP9.2 区间DP与线段树结合9.3 概率区间DP 十、总结与学习建议。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值