結果

問題 No.1641 Tree Xor Query
ユーザー 草苺奶昔
提出日時 2023-03-14 15:42:39
言語 Go
(1.23.4)
結果
AC  
実行時間 282 ms / 5,000 ms
コード長 4,082 bytes
コンパイル時間 12,905 ms
コンパイル使用メモリ 232,044 KB
実行使用メモリ 42,952 KB
最終ジャッジ日時 2024-09-18 08:08:39
合計ジャッジ時間 12,625 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 18
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

package main
import (
    "bufio"
    "fmt"
    "os"
)
func main() {
    in := bufio.NewReader(os.Stdin)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    var n, q int
    fmt.Fscan(in, &n, &q)
    values := make([]int, n)
    for i := 0; i < n; i++ {
        fmt.Fscan(in, &values[i])
    }
    tree := make([][]int, n)
    for i := 0; i < n-1; i++ {
        var a, b int
        fmt.Fscan(in, &a, &b)
        a--
        b--
        tree[a] = append(tree[a], b)
        tree[b] = append(tree[b], a)
    }
    ins, outs, dfsId := make([]int, n+5), make([]int, n+5), 1
    depth := make([]int, n+5)
    var dfsOrder func(cur, pre int)
    dfsOrder = func(cur, pre int) {
        ins[cur] = dfsId
        for _, next := range tree[cur] {
            if next != pre {
                depth[next] = depth[cur] + 1
                dfsOrder(next, cur)
            }
        }
        outs[cur] = dfsId
        dfsId += 1
    }
    dfsOrder(0, -1)
    newNums := make([]int, n)
    for i := 0; i < n; i++ {
        id := outs[i] - 1
        newNums[id] = values[i]
    }
    seg := NewSegmentTree(newNums)
    for i := 0; i < q; i++ {
        var op int
        fmt.Fscan(in, &op)
        if op == 1 {
            var root, xor int
            fmt.Fscan(in, &root, &xor)
            root--
            seg.Set(outs[root]-1, seg.Get(outs[root]-1)^xor)
        } else {
            var root, o int
            fmt.Fscan(in, &root, &o)
            left, right := ins[root-1], outs[root-1]
            left--
            res := seg.Query(left, right)
            fmt.Fprintln(out, res)
        }
    }
}
const INF int = 1e18
// PointSetRangeMin
type E = int
func (*SegmentTree) e() E        { return 0 }
func (*SegmentTree) op(a, b E) E { return a ^ b }
func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}
type SegmentTree struct {
    n, size int
    seg     []E
}
func NewSegmentTree(leaves []E) *SegmentTree {
    res := &SegmentTree{}
    n := len(leaves)
    size := 1
    for size < n {
        size <<= 1
    }
    seg := make([]E, size<<1)
    for i := 0; i < n; i++ {
        seg[i+size] = leaves[i]
    }
    for i := size - 1; i > 0; i-- {
        seg[i] = res.op(seg[i<<1], seg[i<<1|1])
    }
    res.n = n
    res.size = size
    res.seg = seg
    return res
}
func (st *SegmentTree) Get(index int) E {
    if index < 0 || index >= st.n {
        return st.e()
    }
    return st.seg[index+st.size]
}
func (st *SegmentTree) Set(index int, value E) {
    if index < 0 || index >= st.n {
        return
    }
    index += st.size
    st.seg[index] = value
    for index >>= 1; index > 0; index >>= 1 {
        st.seg[index] = st.op(st.seg[index<<1], st.seg[index<<1|1])
    }
}
// [start, end)
func (st *SegmentTree) Query(start, end int) E {
    if start < 0 {
        start = 0
    }
    if end > st.n {
        end = st.n
    }
    if start >= end {
        return st.e()
    }
    leftRes, rightRes := st.e(), st.e()
    start += st.size
    end += st.size
    for start < end {
        if start&1 == 1 {
            leftRes = st.op(leftRes, st.seg[start])
            start++
        }
        if end&1 == 1 {
            end--
            rightRes = st.op(st.seg[end], rightRes)
        }
        start >>= 1
        end >>= 1
    }
    return st.op(leftRes, rightRes)
}
func (st *SegmentTree) QueryAll() E { return st.seg[1] }
// 二分查询最大的 right 使得切片 [left:right] 内的值满足 predicate
func (st *SegmentTree) MaxRight(left int, predicate func(E) bool) int {
    if left == st.n {
        return st.n
    }
    left += st.size
    res := st.e()
    for {
        for left&1 == 0 {
            left >>= 1
        }
        if !predicate(st.op(res, st.seg[left])) {
            for left < st.size {
                left <<= 1
                if predicate(st.op(res, st.seg[left])) {
                    res = st.op(res, st.seg[left])
                    left++
                }
            }
            return left - st.size
        }
        res = st.op(res, st.seg[left])
        left++
        if (left & -left) == left {
            break
        }
    }
    return st.n
}
// 二分查询最小的 left 使得切片 [left:right] 内的值满足 predicate
func (st *SegmentTree) MinLeft(right int, predicate func(E) bool) int {
    if right == 0 {
        return 0
    }
    right += st.size
    res := st.e()
    for {
        right--
        for right > 1 && right&1 == 1 {
            right >>= 1
        }
        if !predicate(st.op(st.seg[right], res)) {
            for right < st.size {
                right = right<<1 | 1
                if predicate(st.op(st.seg[right], res)) {
                    res = st.op(st.seg[right], res)
                    right--
                }
            }
            return right + 1 - st.size
        }
        res = st.op(st.seg[right], res)
        if right&-right == right {
            break
        }
    }
    return 0
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0