HDU - 3974 Assign the task(线段树 + dfs序)

题目链接

思路：裸的线段树，唯一难点就是建树。

dfs序：
作用就是将树上的问题转化为区间问题，用线段树处理区间问题，注意建树前要将dfs序搜出来，
dfs_order[i].first为in[i]左端点，dfs_order[i].second为out[i]右端点
建树：Build(1,1,len);
单点查：Query(1, dfs_order[x].first);
区间改：Update(1, dfs_order[x].first, dfs_order[x].second, y)

注意：
像这种单点查询的直接查询到底，不用PushUp了，因为不会查着到有儿子的点，自定义建树的话要记得在叶子节点return。

代码：

#include <bits/stdc++.h>
#define fastio ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define debug(a) cout << "debug : " << (#a) << " = " << a << endl
#define lson idx << 1
#define rson idx << 1 | 1

using namespace std;

typedef long long ll;
typedef pair<ll, ll> PII;

const int N = 5e4 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 998244353;

int n, m;
struct node
{
    ll l, r, w;
} tree[N << 2];
int lazy[N << 2];
vector<int> a[N];
int ans;
bool vis[N]; //标记i是否有老板

//求dfs序板子
PII dfs_order[N]; //存节点的dfs序
int len;          //表示目前dfs序的长度
void dfs(int x)   //x最开始为根节点
{
    len++;
    dfs_order[x].first = len;
    for (int i = 0; i < a[x].size(); i++)
        dfs(a[x][i]);
    dfs_order[x].second = len;
}

inline void PushDown(ll idx) //idx为此时tree的索引
{
    if (lazy[idx] != -1)
    {
        lazy[lson] = lazy[rson] = lazy[idx];
        tree[lson].w = tree[rson].w = tree[idx].w;
        lazy[idx] = -1;
    }
}

void Build(ll idx, ll l, ll r) //i为此时tree的索引
{
    lazy[idx] = -1;
    tree[idx].l = l;
    tree[idx].r = r;
    tree[idx].w = -1;
    if (l == r) //要记得写到达叶子节点的return
        return;
    ll mid = l + r >> 1;
    Build(lson, l, mid);     //建左子树
    Build(rson, mid + 1, r); //建右子树
}

inline void Update(ll idx, ll l, ll r, ll k)
{
    if (tree[idx].l >= l && tree[idx].r <= r) //此时节点区间若在l~r之内
    {
        tree[idx].w = k;
        lazy[idx] = 1;
        return;
    }
    PushDown(idx);
    if (tree[lson].r >= l)
        Update(lson, l, r, k);
    if (tree[rson].l <= r)
        Update(rson, l, r, k);
}

inline void Query(ll idx, int k)
{
    if (tree[idx].l == tree[idx].r && tree[idx].l == k)
    {
        ans = tree[idx].w;
        return;
    }
    PushDown(idx);
    if (k <= tree[lson].r)
        Query(lson, k);
    if (k >= tree[rson].l)
        Query(rson, k);
}

int main()
{
    fastio;
    int T;
    cin >> T;
    for (int j = 1; j <= T; j++)
    {
        memset(vis, false, sizeof vis);
        cin >> n;
        len = 0;
        for (int i = 1; i <= n; i++)
            a[i].clear();
        for (int i = 1; i <= n - 1; i++)
        {
            int u, v;
            cin >> u >> v;
            a[v].push_back(u);
            vis[u] = true;
        }
        for (int i = 1; i <= n; i++)
        {
            if (!vis[i]) //找到树根求dfs序
            {
                vis[i] = true;
                dfs(i);
                break;
            }
        }
        Build(1, 1, len); //建树的n值是dfs序列的长度最大值
        cin >> m;
        cout << "Case #" << j << ':' << endl;
        while (m--)
        {
            char op;
            int x, y;
            cin >> op >> x;
            if (op == 'C')
            {
                Query(1, dfs_order[x].first); //查找也要用dfs序查找
                cout << ans << endl;
            }
            else
            {
                cin >> y;
                Update(1, dfs_order[x].first, dfs_order[x].second, y);
            }
        }
    }

    return 0;
}