結果

問題 No.1254 補強への架け橋
ユーザー 草苺奶昔
提出日時 2023-03-27 02:13:20
言語 Go
(1.23.4)
結果
AC  
実行時間 234 ms / 2,000 ms
コード長 12,443 bytes
コンパイル時間 13,452 ms
コンパイル使用メモリ 227,288 KB
実行使用メモリ 45,252 KB
最終ジャッジ日時 2024-09-19 10:06:18
合計ジャッジ時間 27,394 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge5
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 123
権限があれば一括ダウンロードができます

ソースコード

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

package main
import (
    "bufio"
    "fmt"
    "os"
    "sort"
    "strings"
)
func main() {
    // a, b, c := BuildNamoriForest(5, []Edge{{0, 1, 1, 0}, {1, 2, 1, 1}, {2, 3, 1, 2}, {3, 4, 1, 3}, {4, 0, 1, 4}}, false)
    // fmt.Println(a[0].CycleEdges, b, c)
    yuki1254()
}
func yuki1254() {
    in := bufio.NewReader(os.Stdin)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    var n int
    fmt.Fscan(in, &n)
    g := make([][]Edge, n)
    for i := 0; i < n; i++ {
        var a, b int
        fmt.Fscan(in, &a, &b)
        a--
        b--
        g[a] = append(g[a], Edge{a, b, 1, i})
        g[b] = append(g[b], Edge{b, a, 1, i})
    }
    G := NewNamoriGraph(g)
    G.Build(false)
    res := []int{}
    for _, e := range G.CycleEdges {
        res = append(res, e.id+1)
    }
    sort.Ints(res)
    fmt.Fprintln(out, len(res))
    for _, v := range res {
        fmt.Fprint(out, v, " ")
    }
}
func abc266_f() {
    // https://atcoder.jp/contests/abc266/tasks/abc266_f
    // 给定一个基环树,问从x到y的路径是否唯一
    // 等价于不能走环上=>在同一个子树中
    in := bufio.NewReader(os.Stdin)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    var n int
    fmt.Fscan(in, &n)
    graph := make([][]Edge, n)
    for i := 0; i < n; i++ {
        var a, b int
        fmt.Fscan(in, &a, &b)
        a--
        b--
        graph[a] = append(graph[a], Edge{a, b, 1, i})
        graph[b] = append(graph[b], Edge{b, a, 1, i})
    }
    G := NewNamoriGraph(graph)
    G.Build(false) // !without HLD
    var q int
    fmt.Fscan(in, &q)
    for i := 0; i < q; i++ {
        var x, y int
        fmt.Fscan(in, &x, &y)
        x--
        y--
        root1, _ := G.GetId(x)
        root2, _ := G.GetId(y)
        if root1 == root2 {
            fmt.Fprintln(out, "Yes")
        } else {
            fmt.Fprintln(out, "No")
        }
    }
}
func namoriCut() {
    // https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2891
    // 给定一个基环树 q个询问(x,y)
    // 求使得x和y不连通最少需要切掉多少条边
    // 如果两个点都在环上,则答案为2
    // 否则答案为1(两点之间只有唯一的一条路径)
    in := bufio.NewReader(os.Stdin)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    var n int
    fmt.Fscan(in, &n)
    graph := make([][]Edge, n)
    for i := 0; i < n; i++ {
        var a, b int
        fmt.Fscan(in, &a, &b)
        a, b = a-1, b-1
        graph[a] = append(graph[a], Edge{a, b, 1, i})
        graph[b] = append(graph[b], Edge{b, a, 1, i})
    }
    G := NewNamoriGraph(graph)
    G.Build(false)
    var q int
    fmt.Fscan(in, &q)
    for i := 0; i < q; i++ {
        var x, y int
        fmt.Fscan(in, &x, &y)
        x, y = x-1, y-1
        _, treeId1 := G.GetId(x)
        _, treeId2 := G.GetId(y)
        if treeId1 != 0 || treeId2 != 0 {
            fmt.Fprintln(out, 1)
        } else {
            fmt.Fprintln(out, 2)
        }
    }
}
func BuildNamoriForest(n int, edges []Edge, needHLD bool) (forest []*NamoriGraph, groupId, idInGroup []int) {
    uf := NewUnionFindArray(n)
    for _, e := range edges {
        uf.Union(e.from, e.to)
    }
    groups := uf.GetGroups()
    idInGroup = make([]int, n)          // 每个点在连通块中的编号
    groupId = make([]int, n)            // 每个点所在的连通块编号
    gs := make([]Graph, 0, len(groups)) // !每个连通块的图
    gid := 0
    for _, g := range groups {
        id := 0
        for _, v := range g {
            groupId[v] = gid
            idInGroup[v] = id
            id++
        }
        gs = append(gs, make(Graph, len(g)))
        gid++
    }
    for _, e := range edges {
        u, v := e.from, e.to
        gid := groupId[u]
        id1, id2 := idInGroup[u], idInGroup[v]
        gs[gid][id1] = append(gs[gid][id1], Edge{from: id1, to: id2, cost: e.cost, id: e.id})
    }
    forest = make([]*NamoriGraph, len(gs))
    for i, g := range gs {
        forest[i] = NewNamoriGraph(g)
        forest[i].Build(needHLD)
    }
    return
}
type NamoriGraph struct {
    // !以环上各个顶点i为根的无向树
    Trees []Graph
    // !基环树中在环上的边,边i连接着树的 root i和i+1 (i>=0)
    CycleEdges []Edge
    // 每个树的重链剖分(需要在Build(needHLD=true)后才能使用)
    HLDs []*_HLD
    g          Graph
    iv         [][]int
    markId, id []int
}
type Edge = struct{ from, to, cost, id int }
type Graph = [][]Edge
func NewNamoriGraph(g Graph) *NamoriGraph {
    return &NamoriGraph{g: g}
}
// needHLD :是否需要对各个子树进行重链剖分.
func (ng *NamoriGraph) Build(needHLD bool) {
    n := len(ng.g)
    deg := make([]int, n)
    used := make([]bool, n)
    que := []int{}
    for i := 0; i < n; i++ {
        deg[i] = len(ng.g[i])
        if deg[i] == 1 {
            que = append(que, i)
            used[i] = true
        }
    }
    for len(que) > 0 {
        idx := que[0]
        que = que[1:]
        for _, e := range ng.g[idx] {
            if used[e.to] {
                continue
            }
            deg[e.to]--
            if deg[e.to] == 1 {
                que = append(que, e.to)
                used[e.to] = true
            }
        }
    }
    mx := 0
    for _, edges := range ng.g {
        for _, e := range edges {
            mx = max(mx, e.id)
        }
    }
    edgeUsed := make([]bool, mx+1)
    loop := []int{}
    for i := 0; i < n; i++ {
        if used[i] {
            continue
        }
        for update := true; update; {
            update = false
            loop = append(loop, i)
            for _, e := range ng.g[i] {
                if used[e.to] || edgeUsed[e.id] {
                    continue
                }
                edgeUsed[e.id] = true
                ng.CycleEdges = append(ng.CycleEdges, Edge{i, e.to, e.cost, e.id})
                i = e.to
                update = true
                break
            }
        }
        break
    }
    if len(loop) > 0 {
        loop = loop[:len(loop)-1]
    }
    ng.markId = make([]int, n)
    ng.id = make([]int, n)
    for i := 0; i < len(loop); i++ {
        pre := loop[(i+len(loop)-1)%len(loop)]
        nxt := loop[(i+1)%len(loop)]
        sz := 0
        ng.markId[loop[i]] = i
        ng.iv = append(ng.iv, []int{})
        ng.id[loop[i]] = sz
        sz++
        ng.iv[len(ng.iv)-1] = append(ng.iv[len(ng.iv)-1], loop[i])
        for _, e := range ng.g[loop[i]] {
            if e.to != pre && e.to != nxt {
                ng.markDfs(e.to, loop[i], i, &sz)
            }
        }
        tree := make(Graph, sz)
        for _, e := range ng.g[loop[i]] {
            if e.to != pre && e.to != nxt {
                tree[ng.id[loop[i]]] = append(tree[ng.id[loop[i]]], Edge{ng.id[loop[i]], ng.id[e.to], e.cost, e.id})
                tree[ng.id[e.to]] = append(tree[ng.id[e.to]], Edge{ng.id[e.to], ng.id[loop[i]], e.cost, e.id})
                ng.buildDfs(e.to, loop[i], tree)
            }
        }
        ng.Trees = append(ng.Trees, tree)
    }
    // HLD
    if !needHLD {
        return
    }
    t := len(ng.Trees)
    ng.HLDs = make([]*_HLD, 0, t)
    for _, tree := range ng.Trees {
        hld := _NewHLD(tree)
        hld.Build(0)
        ng.HLDs = append(ng.HLDs, hld)
    }
}
// 给定原图的顶点rawV,返回rawV所在的树的根节点和rawV在树中的编号.
func (ng *NamoriGraph) GetId(rawV int) (rootId, idInTree int) {
    return ng.markId[rawV], ng.id[rawV]
}
// 给定树的顶点编号root和某个点在树中的顶点编号idInTree,返回这个点在原图中的顶点编号.
//  GetInvId(root,0) 表示在环上的顶点root在原图中对应的顶点.
func (ng *NamoriGraph) GetInvId(rootId, idInTree int) (rawV int) {
    return ng.iv[rootId][idInTree]
}
func (ng *NamoriGraph) markDfs(idx, par, k int, l *int) {
    ng.markId[idx] = k
    ng.id[idx] = *l
    *l++
    ng.iv[len(ng.iv)-1] = append(ng.iv[len(ng.iv)-1], idx)
    for _, e := range ng.g[idx] {
        if e.to != par {
            ng.markDfs(e.to, idx, k, l)
        }
    }
}
func (ng *NamoriGraph) buildDfs(idx, par int, tree Graph) {
    for _, e := range ng.g[idx] {
        if e.to != par {
            tree[ng.id[idx]] = append(tree[ng.id[idx]], Edge{ng.id[idx], ng.id[e.to], e.cost, e.id})
            tree[ng.id[e.to]] = append(tree[ng.id[e.to]], Edge{ng.id[e.to], ng.id[idx], e.cost, e.id})
            ng.buildDfs(e.to, idx, tree)
        }
    }
}
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}
type _HLD struct {
    Tree                          Graph
    SubSize, Depth, Parent        []int
    dfn, dfnToNode, top, heavySon []int
    dfnId                         int
}
func (hld *_HLD) Build(root int) {
    hld.build(root, -1, 0)
    hld.markTop(root, root)
}
func _NewHLD(tree Graph) *_HLD {
    n := len(tree)
    dfn := make([]int, n)       // vertex => dfn
    dfnToNode := make([]int, n) // dfn => vertex
    top := make([]int, n)       // 所处轻/重链的顶点（深度最小），轻链的顶点为自身
    subSize := make([]int, n)   // 子树大小
    depth := make([]int, n)     // 深度
    parent := make([]int, n)    // 父结点
    heavySon := make([]int, n)  // 重儿子
    return &_HLD{
        Tree:      tree,
        dfn:       dfn,
        dfnToNode: dfnToNode,
        top:       top,
        SubSize:   subSize,
        Depth:     depth,
        Parent:    parent,
        heavySon:  heavySon,
    }
}
// 返回树节点 u 对应的 欧拉序区间 [down, up).
//  0 <= down < up <= n.
func (hld *_HLD) Id(u int) (down, up int) {
    down, up = hld.dfn[u], hld.dfn[u]+hld.SubSize[u]
    return
}
// 返回边 u-v 对应的 欧拉序起点编号.
func (hld *_HLD) Eid(u, v int) int {
    id1, _ := hld.Id(u)
    id2, _ := hld.Id(v)
    if id1 < id2 {
        return id2
    }
    return id1
}
// 处理路径上的可换操作.
//   0 <= start <= end <= n, [start,end).
func (hld *_HLD) QueryPath(u, v int, vertex bool, f func(start, end int)) {
    if vertex {
        hld.forEach(u, v, f)
    } else {
        hld.forEachEdge(u, v, f)
    }
}
// 处理以 root 为根的子树上的查询.
//   0 <= start <= end <= n, [start,end).
func (hld *_HLD) QuerySubTree(u int, vertex bool, f func(start, end int)) {
    if vertex {
        f(hld.dfn[u], hld.dfn[u]+hld.SubSize[u])
    } else {
        f(hld.dfn[u]+1, hld.dfn[u]+hld.SubSize[u])
    }
}
func (hld *_HLD) forEach(u, v int, cb func(start, end int)) {
    for {
        if hld.dfn[u] > hld.dfn[v] {
            u, v = v, u
        }
        cb(max(hld.dfn[hld.top[v]], hld.dfn[u]), hld.dfn[v]+1)
        if hld.top[u] != hld.top[v] {
            v = hld.Parent[hld.top[v]]
        } else {
            break
        }
    }
}
func (hld *_HLD) LCA(u, v int) int {
    for {
        if hld.dfn[u] > hld.dfn[v] {
            u, v = v, u
        }
        if hld.top[u] == hld.top[v] {
            return u
        }
        v = hld.Parent[hld.top[v]]
    }
}
func (hld *_HLD) Dist(u, v int) int {
    return hld.Depth[u] + hld.Depth[v] - 2*hld.Depth[hld.LCA(u, v)]
}
// 寻找以 start 为 top 的重链 ,heavyPath[-1] 即为重链末端节点.
func (hld *_HLD) GetHeavyPath(start int) []int {
    heavyPath := []int{start}
    cur := start
    for hld.heavySon[cur] != -1 {
        cur = hld.heavySon[cur]
        heavyPath = append(heavyPath, cur)
    }
    return heavyPath
}
func (hld *_HLD) forEachEdge(u, v int, cb func(start, end int)) {
    for {
        if hld.dfn[u] > hld.dfn[v] {
            u, v = v, u
        }
        if hld.top[u] != hld.top[v] {
            cb(hld.dfn[hld.top[v]], hld.dfn[v]+1)
            v = hld.Parent[hld.top[v]]
        } else {
            if u != v {
                cb(hld.dfn[u]+1, hld.dfn[v]+1)
            }
            break
        }
    }
}
func (hld *_HLD) build(cur, pre, dep int) int {
    subSize, heavySize, heavySon := 1, 0, -1
    for _, e := range hld.Tree[cur] {
        next := e.to
        if next != pre {
            nextSize := hld.build(next, cur, dep+1)
            subSize += nextSize
            if nextSize > heavySize {
                heavySize, heavySon = nextSize, next
            }
        }
    }
    hld.Depth[cur] = dep
    hld.SubSize[cur] = subSize
    hld.heavySon[cur] = heavySon
    hld.Parent[cur] = pre
    return subSize
}
func (hld *_HLD) markTop(cur, top int) {
    hld.top[cur] = top
    hld.dfn[cur] = hld.dfnId
    hld.dfnId++
    hld.dfnToNode[hld.dfn[cur]] = cur
    if hld.heavySon[cur] != -1 {
        hld.markTop(hld.heavySon[cur], top)
        for _, e := range hld.Tree[cur] {
            next := e.to
            if next != hld.heavySon[cur] && next != hld.Parent[cur] {
                hld.markTop(next, next)
            }
        }
    }
}
// NewUnionFindWithCallback ...
func NewUnionFindArray(n int) *UnionFindArray {
    parent, rank := make([]int, n), make([]int, n)
    for i := 0; i < n; i++ {
        parent[i] = i
        rank[i] = 1
    }
    return &UnionFindArray{
        Part:   n,
        rank:   rank,
        n:      n,
        parent: parent,
    }
}
type UnionFindArray struct {
    // 连通分量的个数
    Part int
    rank   []int
    n      int
    parent []int
}
func (ufa *UnionFindArray) Union(key1, key2 int) bool {
    root1, root2 := ufa.Find(key1), ufa.Find(key2)
    if root1 == root2 {
        return false
    }
    if ufa.rank[root1] > ufa.rank[root2] {
        root1, root2 = root2, root1
    }
    ufa.parent[root1] = root2
    ufa.rank[root2] += ufa.rank[root1]
    ufa.Part--
    return true
}
func (ufa *UnionFindArray) Find(key int) int {
    for ufa.parent[key] != key {
        ufa.parent[key] = ufa.parent[ufa.parent[key]]
        key = ufa.parent[key]
    }
    return key
}
func (ufa *UnionFindArray) IsConnected(key1, key2 int) bool {
    return ufa.Find(key1) == ufa.Find(key2)
}
func (ufa *UnionFindArray) GetGroups() map[int][]int {
    groups := make(map[int][]int)
    for i := 0; i < ufa.n; i++ {
        root := ufa.Find(i)
        groups[root] = append(groups[root], i)
    }
    return groups
}
func (ufa *UnionFindArray) Size(key int) int {
    return ufa.rank[ufa.Find(key)]
}
func (ufa *UnionFindArray) String() string {
    sb := []string{"UnionFindArray:"}
    for root, member := range ufa.GetGroups() {
        cur := fmt.Sprintf("%d: %v", root, member)
        sb = append(sb, cur)
    }
    sb = append(sb, fmt.Sprintf("Part: %d", ufa.Part))
    return strings.Join(sb, "\n")
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0