启发式树上主席树合并、克鲁斯卡尔重构树 学习笔记

最新推荐文章于 2022-02-24 21:51:26 发布
最新推荐文章于 2022-02-24 21:51:26 发布
阅读量208 收藏
点赞数
分类专栏： 数据结构 学习计划 生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zenith_Habitant/article/details/109644686
版权
  • 题目链接：https://www.luogu.com.cn/problem/P3302
  • 启发式主席树合并基础题目，和启发式并查集方法保持一致，按秩合并即可，该主席树维护的是根节点到树上任意节点的内容，和 count on tree这个题目维护的内容一样，只是在这个题目的基础上加上了启发式合并
//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 7e5 + 5;
int T, n , m , Q, len;
int a[N], b[N], fa[N], son[N], vis[N];
int bz[N][25], dep[N];
vector <int> edge[N];

int tot , lc[N*50] , rc[N*50], siz[N*50], rt[N*50];
int findroot (int x)
{
    if (fa[x] == x)
        return x;
    return fa[x] = findroot (fa[x]);
}
void build(int& rt, int l , int r) //采用引用，同时给左右儿子编号，&rt相当于lc[rt],rt变换，lc[rt]也会变换
{
    rt = ++ tot; //用于节点编号，和线段树有所不同，不能根据公示得到左右儿子，需要动态编号
    if(l == r)
        return ;
    int mid = (l+r) >> 1;
    build(lc[rt], l , mid); //左儿子
    build(rc[rt],mid+1,r); //右儿子
    //如果这种不理解，下面的build也是可以的
}
int update(int pre , int l , int r , int k)
{
    int now = ++ tot;
    lc[now] = lc[pre] , rc[now] = rc[pre] , siz[now] = siz[pre] + 1;
    if(l == r) return now;
    int mid = (l + r) >> 1;
    if (k <= mid)
        lc[now] = update(lc[now] , l, mid, k);
    else
        rc[now] = update(rc[now] , mid + 1, r , k);
    return now;
}
int query(int rt1, int rt2, int rt3 ,int rt4, int l , int r, int k)
{
    int mid = (l + r) >> 1;
    int x = siz[lc[rt1]] + siz[lc[rt2]] - siz[lc[rt3]] - siz[lc[rt4]];
    if(l == r) return l;
    if(x >= k)
        return query(lc[rt1], lc[rt2], lc[rt3] , lc[rt4] , l , mid , k);
    else
        return query(rc[rt1], rc[rt2], rc[rt3] , rc[rt4] , mid + 1 , r , k - x);
}
void dfs (int u, int pa, int root)
{
    bz[u][0] = pa;
    for (int i = 1 ; i <= 20 ; i ++)
        bz[u][i] = bz[bz[u][i-1]][i-1];
    son[root] ++;
    dep[u] = dep[pa] + 1;
    vis[u] = 1;
    rt[u] = update (rt[pa], 1, len , lower_bound(b+1,b+1+len,a[u])-b);
    for (auto v : edge[u])
    {
        if (v != pa)
            dfs (v, u, root);
    }
}
int LCA(int x,int y)
{
    if(dep[x] < dep[y])
        swap(x,y);
    int t = dep[x] - dep[y];
    for(int i = 0; (1<<i) <= t ; i ++)
        if((1<<i)&t)x=bz[x][i];
    for(int i=20 ; i >= 0 ; i--)
        if(bz[x][i] ^ bz[y][i])
            x=bz[x][i], y=bz[y][i];
    if(x==y) return x;
    return bz[x][0];
}
int main ()
{
    read (T);
    T = 1;
    while (T --)
    {
        tot = 0;
        mem (dep, 0), mem(vis,0), mem(bz,0), mem(son,0);
        int last = 0;
        read (n , m, Q);
        for (int i = 1 ; i <= n ; i ++)
            edge[i].clear();
        for (int i = 1 ; i <= n ; i ++)
            read (a[i]) , b[i] = a[i], fa[i] = i;
        sort (b + 1, b + 1 + n);
        len = unique (b + 1, b + 1 + n) - b - 1;
        build (rt[0], 1, len);
        for (int i = 1 ; i <= m ; i ++)
        {
            int u , v;
            read (u, v);
            edge[u].pb(v), edge[v].pb(u);
        }
        for (int i = 1 ; i <= n ; i ++)
        {
            if (!vis[i])
            {
                dfs (i, 0 , i);
                fa[i] = i;
            }
        }
        while (Q --)
        {
            char op[2];
            scanf ("%s",op);
            int u , v, k;
            if(op[0] == 'Q')
            {
                read (u, v, k);
                u ^= last;
                v ^= last;
                k ^= last;
                int lca = LCA(u, v);
                int f_lca = bz[lca][0];
                int ans = b[query(rt[u], rt[v], rt[lca], rt[f_lca] ,1, len, k)];
                write (ans), LF;
                last = ans;
            }
            else
            {
                read(u, v);
                u ^= last;
                v ^= last;
                edge[u].pb(v);
                edge[v].pb(u);
                int fax = findroot(u);
                int fay = findroot(v);
                if (son[fax] < son[fay])
                    swap(u, v), swap(fax, fay);
                dfs(v, u, fax);
            }
        }
    }
}
  • 题目链接：https://www.luogu.com.cn/problem/P4197
  • 克鲁斯卡尔重构树经典题目 ，本题两个难点，一个是处理出在对应边权限制下快速处理出所有能到达的点，这个地方使用克鲁斯卡尔重构树就可以解决，还有一个问题就是如何快速查询出子树中的第k大的点，这个地方用主席树搞一搞就好了（注意：这里是对重构树按dfs序建立主席树，中间会产生很多无用点，跳过就好了）
//检查一下每个节点的父亲节点，存在问题
//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 5e5 + 5;
int n , m , q, tot, len;
int a[N], b[N], fa[N], val[N*2];
struct node {
    int u , v, w;
    bool operator < (const node& no) const {
        return w < no.w;
    }
}E[N];
vector <int> edge[N];
int dfn[N] , times;
int ntot , lc[N*50] , rc[N*50], siz[N*50], rt[N*50];
int psiz[N];
int findroot (int x)
{
    if (fa[x] == x) return fa[x];
    return fa[x] = findroot (fa[x]);
}
bool merge (int x, int y, int w)
{
    int fax = findroot (x);
    int fay = findroot (y);
    if (fax != fay)
    {
        ++ ntot;
        val[ntot] = w;
        edge[ntot].pb(fax), edge[ntot].pb(fay),edge[fax].pb(ntot),edge[fay].pb(ntot);
        fa[fax] = fa[fay] = fa[ntot] = ntot;
        return true;
    }
    return false;
}
void build(int& rt, int l , int r) //采用引用，同时给左右儿子编号，&rt相当于lc[rt],rt变换，lc[rt]也会变换
{
    rt = ++ tot; //用于节点编号，和线段树有所不同，不能根据公示得到左右儿子，需要动态编号
    if(l == r) return ;
    int mid = (l+r) >> 1;
    build(lc[rt], l , mid); //左儿子
    build(rc[rt],mid+1,r); //右儿子
    //如果这种不理解，下面的build也是可以的
}
int update(int pre , int l , int r , int k)
{
    int now = ++ tot;
    lc[now] = lc[pre] , rc[now] = rc[pre];
    if (k != 0) siz[now] = siz[pre] + 1;
    else siz[now] = siz[pre];
    if(l == r) return now;
    int mid = (l + r) >> 1;
    if (k <= mid)
        lc[now] = update(lc[now] , l, mid, k);
    else
        rc[now] = update(rc[now] , mid + 1, r , k);
    return now;
}
int query(int u , int v, int l , int r, int k)
{
    //两颗线段树做差之后，就相当于是[l-1,r]区间构成的线段树了，就可以转换为权值线段树Kth操作了
    int mid = (l + r) >> 1,  x = siz[lc[v]] - siz[lc[u]];
    if(l == r) return l;
    if(x >= k)
        return query(lc[u],lc[v],l,mid,k);
    else
        return query(rc[u],rc[v],mid+1,r,k-x);
}

int bz[N][25], dep[N];
void dfs (int u , int pa)
{
    psiz[u] = 1;
    dfn[u] = ++ times;
    if (a[u] != 0)
        rt[times] = update(rt[times - 1], 1, len, lower_bound(b + 1, b + 1 + len, a[u]) - b);
    else
        rt[times] = update(rt[times-1], 1, len, 0);
    for (auto v : edge[u])
    {
        if (v != pa)
        {
            dep[v] = dep[u] + 1;
            bz[v][0] = u;
            dfs (v, u);
            psiz[u] += psiz[v];
        }
    }
}
void deal()
{
    for(int i = 1 ; i <= 20 ; i ++)
        for(int j = 1 ; j <= ntot ; j ++)
            bz[j][i] = bz[bz[j][i-1]][i-1];
}
int main ()
{
    read (n, m , q);
    ntot = n;
    for (int i = 1 ; i <= n ; i ++)
        read (a[i]), b[i] = a[i], fa[i] = i;
    sort (b + 1 , b + 1 + n);
    len = unique (b + 1, b + 1 + n) - b - 1;
    for (int i = 1 ; i <= m ; i ++)
        read (E[i].u,E[i].v,E[i].w);
    sort (E+1,E+1+m);
    for (int i = 1 ; i <= m ; i ++)
        merge (E[i].u , E[i].v, E[i].w);
    build (rt[0], 1, len);
    dfs (ntot, 0);
    deal();
    while (q --)
    {
        int v , x, k;
        read (v, x, k);
        int u = v;
        for (int i = 20 ; i >= 0 ; i --)
        {
            if (val[bz[u][i]] <= x && bz[u][i] != 0)
                u = bz[u][i];
        }
        //cout << siz[rt[dfn[u]+psiz[u]-1]] << ' ' << siz[rt[dfn[u]]] << endl;
        int pp = siz[rt[dfn[u]+psiz[u]-1]] - siz[rt[dfn[u]]];
        if (siz[rt[dfn[u]+psiz[u]-1]] - siz[rt[dfn[u]]] >= k) {
            write(b[query(rt[dfn[u]], rt[dfn[u] + psiz[u] - 1], 1, len, pp - k + 1)]), LF;
        }
        else
            write(-1),LF;
    }


}
  • 题目链接：https://www.luogu.com.cn/problem/P4768
  • 解题思路：一般看到有限制条件的需要快速判断一个点能够到达哪些点，并且答案和这些点相关的，都可以考虑重构树之后解决。
//检查一下每个节点的父亲节点，存在问题
//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 6e5 + 5;
int T;
int n , m;
int Q, k, s;
int head[N] , cnt;
struct node1 {
    int u , v , w, x;
    bool operator < (const node1& no) const {
        return x > no.x;
    }
}E[N];
struct node2 {
    int t, next, w;
}edge[N << 1];
void add (int f, int t, int w)
{
    edge[cnt].t = t;
    edge[cnt].w = w;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
ll dis[N], dp[N];
struct node
{
    int v;
    ll value;
    node(int a, ll b):v(a),value(b){};
    //在堆中这样代表从小到大排序
    bool operator < (const node& no) const {
        return value > no.value;
    }
};
void dijkstra(int s)
{
    mem(dis,INF);
    p_queue <node> q;
    dis[s] = 0;
    q.push(node(s,0));
    while(!q.empty())
    {
        node no = q.top();
        q.pop();
        int u = no.v;
        for(int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].t , w = edge[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                q.push(node(v,dis[v]));
            }
        }
    }
}
int ntot, fa[N], val[N], bz[N][25];
vector <int> Edge[N];
int findroot (int x)
{
    if (fa[x] == x) return x;
    return fa[x] = findroot (fa[x]);
}
void merge (int x, int y, int w)
{
    int fax = findroot (x);
    int fay = findroot (y);
    if (fax != fay)
    {
        ++ ntot;
        val[ntot] = w;
        Edge[ntot].pb(fax), Edge[fax].pb(ntot);
        Edge[ntot].pb(fay), Edge[fay].pb(ntot);
        fa[fax] = fa[fay] = fa[ntot] = ntot;
    }
}
void dfs (int u, int pa)
{
    for (auto v : Edge[u])
    {
        if (v != pa)
        {
            bz[v][0] = u;
            dfs (v, u);
            dp[u] = min (dp[v], dp[u]);
        }
    }
}
void deal ()
{
    for (int i = 1 ; i <= 20 ; i ++)
        for (int j = 1 ; j <= ntot ; j ++)
            bz[j][i] = bz[bz[j][i-1]][i-1];
}
int main ()
{
    read (T);
    while (T --)
    {
        mem (bz,0);
        mem (val ,-1);
        mem (dp, INF);
        mem (dis, INF);
        mem (head, -1), cnt = 0;
        read (n, m);
        for (int i = 1 ; i <= n ; i ++) fa[i] = i;
        ntot = n;
        for (int i = 1 ; i <= m ; i ++)
        {
            read (E[i].u, E[i].v, E[i].w, E[i].x);
            add (E[i].u, E[i].v, E[i].w);
            add (E[i].v, E[i].u, E[i].w);
        }
        dijkstra (1);
        for (int i = 1 ; i <= ntot ; i ++)
            dp[i] = dis[i];
        sort (E + 1, E + 1 + m);
        for (int i = 1 ; i <= m ; i ++)
        {
            int u = E[i].u, v = E[i].v, x = E[i].x;
            merge (u, v, x);
        }
        dfs (ntot, 0);
        deal ();
        read (Q, k ,s);
        ll last = 0;
        while (Q --)
        {
            ll u , x;
            read (u, x);
            if (k == 1)
            {
                u = ((u + k * last - 1) % n) +1;
                x = (x + k * last) % (s + 1);
            }
            for (int j = 20 ; j >= 0 ; j --)
            {
                if (val[bz[u][j]] > x)
                    u = bz[u][j];
            }
            write (dp[u]), LF;
            last = dp[u];
        }
        for (int i = 1 ; i <= ntot ; i ++)
            Edge[i].clear();
    }
}
  • 题目链接：https://codeforces.com/problemset/problem/1416/D
  • 解题思路：首先这个题目删边不好搞，我们可以考虑时光倒流，删边边加边，如果这个题目没有把最大的节点变成0这个条件的话，那么只需要随便搞一下就好了，但是，问题就是这个题有变0操作，并且和操作顺序相关。怎么解决？
    这里我们构建一颗克鲁斯卡尔重构树，对于一般的克鲁斯卡尔重构树，新增节点存的都是边权，这里我们把操作的序号作为时间构建，那么这样的话，我们就可以快速查找出满足这个时间轴下从v出发的最大节点了（克鲁斯卡尔重构树本身就可以快速找出所有从v出发的点，这里我们将时间作为点权后，又可以同时保证时间性）。我们利用线段树维护一下子树，每次查询后修改一下子树节点内容即可
//检查一下每个节点的父亲节点，存在问题
//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 1e6 + 5;
int n , m,  q;
int a[N], fa[N], ntot, val[N];
struct node1 {
    int u , v;
}E[N];
struct node2 {
    int op, x;
}Q[N];
vector <int> edge[N];
int vis[N];
int findroot (int x)
{
    if (fa[x] == x) return fa[x];
    return fa[x] = findroot (fa[x]);
}
void merge (int x, int y, int w)
{
    int fax = findroot (x);
    int fay = findroot (y);
    if (fax != fay)
    {
        ++ntot;
        val[ntot] = w;
        edge[ntot].pb(fax), edge[fax].pb(ntot);
        edge[ntot].pb(fay), edge[fay].pb(ntot);
        fa[fax] = fa[fay] = fa[ntot] = ntot;
    }
}
int dfn[N], times, bz[N][25], siz[N], ver[N];
void dfs (int u , int pa)
{
    siz[u] = 1;
    dfn[u] = ++ times;
    ver[times] = u;
    for (auto v : edge[u])
    {
        if (v != pa)
        {
            bz[v][0] = u;
            dfs(v, u);
            siz[u] += siz[v];
        }
    }
}
void deal ()
{
    for (int i = 1 ; i <= 20 ; i ++)
        for (int j = 1 ; j <= ntot ; j ++)
            bz[j][i] = bz[bz[j][i-1]][i-1];
}
pii p[N*4];
void insert (int i , int l , int r, int id, int x)
{
    if (l == r)
    {
        p[i].fi = x;
        p[i].se = id;
        return ;
    }
    int mid = (l + r) >> 1;
    if (id <= mid)
        insert (i << 1 , l , mid , id, x);
    else
        insert (i << 1 | 1 , mid + 1, r , id, x);
    p[i] = max(p[i<<1],p[i<<1|1]);
    return ;
}
pii query (int i , int L, int R, int l , int r)
{
    pii ans;
    ans.fi = 0 , ans.se = 0;
    if (L >= l && R <= r)
        return p[i];
    int mid = (L + R) / 2;
    if (l <= mid)
        ans = max (ans, query(i<<1,L,mid,l,r));
    if (mid < r)
        ans = max (ans,query(i<<1|1,mid+1,R,l,r));
    return ans;
}
int main ()
{
    read (n, m , q);
    ntot = n;
    for (int i = 1 ; i <= n ; i ++)
        read (a[i]), fa[i] = i;
    for (int i = 1 ; i <= m ; i ++)
        read(E[i].u , E[i].v);
    for (int i = 1 ; i <= q ; i ++) {
        read(Q[i].op , Q[i].x);
        if (Q[i].op == 2)
            vis[Q[i].x] = 1;
    }

    for (int i = 1 ; i <= m ; i ++)
        if (!vis[i])
            merge (E[i].u, E[i].v, q);

    for (int i = q ; i >= 1 ; i --)
        if (Q[i].op == 2)
            merge (E[Q[i].x].u, E[Q[i].x].v, i);

    for (int i = 1 ; i <= ntot ; i ++)
        if (findroot (i) == i)
            dfs (i, 0);
    deal();
    for (int i = 1 ; i <= n ; i ++)
        insert (1, 1, ntot, dfn[i], a[i]);
    for (int i = 1; i <= q ;i  ++)
    {
        if (Q[i].op == 1)
        {
            int u = Q[i].x;
            for (int j = 20 ; j >= 0 ; j --)
            {
                if (val[bz[u][j]] >= i)
                    u = bz[u][j];
            }
            auto tmp = query (1, 1 , ntot, dfn[u], dfn[u] + siz[u] - 1);
            write(tmp.fi), LF;
            if (tmp.se != 0)
                insert (1, 1, ntot, tmp.se, 0);
        }
    }

}
卡常带师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习与深度学习面试系列六（决策树）1
08-03
一是如何选择最佳的树结构，这通常采用启发式方法，例如ID3（Iterative Dichotomiser 3）、C4.5和CART（Classification and Regression Trees）等算法。二是何时停止构建树，以防止过拟合，即模型过于复杂而对新数据...
启发式搜索-TSP.zip
06-28
启发式搜索是一种优化技术，常用于解决复杂度高、难以找到最优解的组合优化问题，如旅行商问题（TSP）。TSP问题的核心是寻找一个城市的最短访问路径，使得每个城市只被访问一次，最后返回起点。在这个问题中，启发式...
可持久化并查集【主席树】【启发式合并】
//(^ o ^)//
02-24 192
>Link luogu P3402 >Description >解题思路 直接暴力空间会爆。 我们发现一次合并只会修改一个节点的信息。可持久化结构我们会想到主席树，用线段树换数组获取总体更少的空间，那我们就用主席树来储存某个时刻某个节点的父亲 然后询问就直接查询两个点的祖先是否一样即可 合并不压缩路径（据说会mle和tle），为了不tle，就用到启发式合并，集合深度小的并到大的（因为查询祖先的时候与集合深度有关） >代码 #include <iostream> #
【线段树/主席树/线段树合并】总结
weixin_30527423的博客
05-28 210
普通线段树 基于将区间拆分为$O(logn)$区间的并这一思想来实现。其中附加信息的维护方式变化很灵活。 区间加。利用懒标记直接维护。 区间加&区间乘。两个懒标记同时维护，其中乘法更新要带动加法更新。 区间染色。一个懒标记直接覆盖即可。 区间gcd。 树上。有点类似树剖，直接利用DFS序转化为线性，然后普通维护就好了。 维护最小值的位置。query函数的类型作为结构体，每...
BZOJ3123: [Sdoi2013]森林
weixin_30270561的博客
05-24 121
BZOJ3123: [Sdoi2013]森林 Description 小Z有一片森林，含有N个节点，每个节点上都有一个非负整数作为权值。初始的时候，森林中有M条边。 小Z希望执行T个操作，操作有两类： 1. Q x y k查询点x到点y路径上所有的权值中，第k小的权值是多少。此操作保证点x和点y连通，同时这两个节点的路径上至少有k个点。 2. L x y在点x和点y之间连接一条边。保证完...
【bzoj3681】Arietta 【网络流】【主席树】【启发式合并】
2016gdgzoi471
06-15 583
题目链接 题解：这是一个网络流的模型，很容易看出来。 首先让我们考虑一个朴素的网络流建模： s−&gt;力度i：t[i]s−&gt;力度i：t[i]s->力度i：t[i] 力度i−&gt;可以弹奏的音符j(j在d[i]子树中，l[i]&lt;=h[j]&lt;=r[i])：inf力度i−&gt;可以弹奏的音符j(j在d[i]子树中，l[i]&lt;=h[j]&lt;=r[i])：inf力度...
[BZOJ3123][SDOI2013]森林（主席树合并）
薇小薇
04-10 273
题目： 我是超链接 题解： 一个是链上求第k大，另一个是连接一条边，强制在线 这样不是连通块内的第k大我们考虑权值线段树，连接一条边就是线段树的合并，对于链上的问题，我们需要采用可持久化的线段树-主席树，而且是树上主席树，即给每个点建一棵主席树，维护到根节点的所有点，这样答案就是sum(a)+sum(b)−sum(lca(a,b))−sum(fa(lca(a,b))) 还要连接一条边...
搜索博弈树的启发式搜索PPT学习教案.pptx
10-01
搜索博弈树的启发式搜索 博弈树是指在博弈过程中，每一个可能的走步都可以衍生出一个新的节点，而这些节点之间通过边相连接，形成一个树形结构。博弈树可以分为双人完备信息博弈和机遇性博弈两种。其中，双人完备...
博弈树的启发式搜索
04-16
人工智能中博弈树的启发式搜索策略，分为极大极小算法和α-β剪枝技术！
配电网重构的启发式算法(matlab代码)
最新发布
06-24
本文提出了一种两阶段的启发式计算方法，可以在最小的计算时间内重新配置一个径向分布网络。所有的网络交换机在操作的初始阶段都是关闭的，并提出了一个顺序的开关开闸策略，以获得一个接近最优的径向配置。在随后的...
3123: [Sdoi2013]森林 主席树的启发式合并
TYB的博客
01-08 287
题面是图片就不复制了…… 题解： 询问可以用主席树轻松地解决，但是连边的话就有点麻烦了，本题采用启发式合并来解决这个问题。启发式合并实际上就是把小的合并到大的上面，这样每次size至少都会翻倍，最多翻倍lognlogn次，对于主席树来说，每次合并重新建树要nlognnlogn的时间，所以总的时间复杂度为O(nlog2n)O(nlog^2n)。注意连边的时候一定要连双向边。 代码： #inc
NKOJ 2638 （SDOI 2013） 森林 （启发式LCA+主席树）
Mogician_Evian的博客
11-27 344
P2638【SDOI2013 R1 Day1】森林问题描述输入格式 第一行包含一个正整数testcase，表示当前测试数据的测试点编号。保证1≤testcase≤20。 第二行包含三个整数N，M，T，分别表示节点数、初始边数、操作数。第三行包含N个非负整数表示 N个节点上的权值。 接下来 M行，每行包含两个整数x和 y，表示初始的时候，点x和点y 之间有一条无向边, 接下来 T
BZOJ 3123 主席树 启发式合并
weixin_33888907的博客
01-10 103
思路： 主席树 搞树上的k大 x+y-lca(x,y)-fa(lca(x,y)) 按照size小树往大树上插 启发式合并 n*log^2n的 搞定~ //By SiriusRen #include <cstdio> #include <cstring> #include <algorithm> using namespace st...
[学习笔记]kruskal重构树 && 并查集重构树
weixin_33774883的博客
01-08 261
Kruskal 重构树 [您有新的未分配科技点][BZOJ3545&BZOJ3551]克鲁斯卡尔重构树 kruskal是一个性质优秀的算法 加入的边是越来越劣的 科学家们借这个特点尝试搞一点事情。 kruskal求最小生成树的过程，如果把加入的一个边新建一个节点的话，并且把k1,k2的father设为新点的话，会得到一个2*n大小的树 实际上已经非常明白地表示kruskal这个...
bzoj2733: [HNOI2012]永无乡（并查集+主席树）
Hanks_o的博客
04-16 267
题目传送门 。 解法： 跟3545解法差不多。 https://blog.csdn.net/hanks_o/article/details/79903342 这道题还没了边权。 直接连通。 那么并查集。 据说要启发式。 小的向大的合并。 然后就没了？ 代码实现： #include&lt;cstdio&gt; #include&lt;cstring&gt; #includ...
[BZOJ3123][Sdoi2013]森林（主席树+启发式合并）
ADP+Pi==ATP
12-18 1798
就因为ATP这篇题解的摘要一开始写了个“zyf2000的头发短得匪夷所思= =”，结果zyf2000竟然去给点了一个“踩”。。。。=n=
[POJ]2104 K-th Number 主席树&线段树合并&整体二分
TYB的博客
06-28 627
两个月前打了个主席树……今天又打了个线段树合并，发现线段树合并的代码挺短的……（其实也差不多） 主席树： #include #include #include #include #define maxn 100010 using namespace std; int A[maxn],b[maxn],n,m; struct array { int x,id; }a[maxn]; bool cm
【bzoj2212】[Poi2011]Tree Rotations（线段树的合并）（主席树-可持久化线段树）
qq_36782366的博客
08-11 408
POI 18 Tree Rotations • http://main.edu.pl/en/archive/oi/18/rot 题目大意： • 给定一棵2n-1个节点的二叉树，每个叶子上有1~n的数字，保证每 个数字出现且仅出现一次 • 允许任意次交换某两棵兄弟子树 • 对交换完毕的树求先序遍历，形成1~n的一个排列 • 求这个排列最小的逆序对个数 • 1 ≤ n ≤
二维偏序/数点——学习笔记
Zenith_Habitant的博客
11-23 1218
二维偏序/数点 对于可离线的二维偏序问题一般都是先定一维的顺序，然后利用树状数组维护求解 应用 一. 题目链接：https://www.luogu.com.cn/problem/P2163 解题思路：二维数点的经典模板题，离线询问之后利用二维前缀和方法用树状数组维护即可 //#define LOCAL #include <bits/stdc++.h> using namespace std; #define ll long long #define mem(a, b) memset(
Murthy, S. K. (1998). Data Mining and Knowledge Discovery, 2(4),
08-03
尽管这些学科的研究目标可能各异，但它们在构建决策树的过程中发现了许多共同的问题和启发式方法。 Murthy的文章首先介绍了决策树的基本概念，它们通过一系列基于数据属性的规则来划分数据集，最终形成一个层次结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值