3628 边的删减(最短路树)

1. 问题描述:

给定一个由 n 个点和 m 条边组成的无向连通加权图。设点 1 到点 i 的最短路径长度为 di。现在,你需要删掉图中的一些边,使得图中最多保留 k 条边。如果在删边操作全部完成后,点 1 到点 i 的最短路径长度仍为 di,则称点 i 是一个优秀点。你的目标是通过合理进行删边操作,使得优秀点的数量尽可能大。

输入格式

第一行包含三个整数 n,m,k。接下来 m 行,每行包含三个整数 x,y,w,表示点 x 和点 y 之间存在一条长度为 w 的边。保证给定无向连通图无重边和自环。

输出格式

第一行包含一个整数 e,表示保留的边的数量 (0 ≤ e ≤ k)。第二行包含 e 个不同的 1∼m 之间的整数,表示所保留的边的编号。按输入顺序,所有边的编号从 1 到 m。你提供的方案,应使得优秀点的数量尽可能大。如果答案不唯一,则输出任意满足条件的合理方案均可。

数据范围

对于前五个测试点,2 ≤ n ≤ 15,1 ≤ m ≤ 15。
对于全部测试点,2 ≤ n ≤ 10 ^ 5,1 ≤ m ≤ 10 ^ 5,n − 1 ≤ m,0 ≤ k ≤ m,1 ≤ x,y ≤ n,x ≠ y,1 ≤ w ≤ 10 ^ 9。

输入样例1:

3 3 2
1 2 1
3 2 1
1 3 3

输出样例1:

2
1 2

输入样例2:

4 5 2
4 1 8
2 4 1
2 1 3
3 4 9
3 1 5

输出样例2:

2
3 2
来源:https://www.acwing.com/problem/content/description/3631/

2. 思路分析:

分析题目可以知道我们去掉的边肯定不是到达某个点的最短路径中的边,所以保留最短路径上的边所有点的最短路径是不变的,因为边权大于0所以我们可以使用堆优化版的dijkstra算法求解出从1号点到其余点的最短路径,如何判断出当前的边是否是最短路径上的边呢?当我们求解出从起点到其余点的最短距离之后,遍历每一条边,如果发现dis[j] = dis[i] + w,说明节点i是由节点j更新过来的,所以属于最短路径上的边;当我们求解出了从1号点到其余点的最短距离之后那么可以使用dfs遍历所有的边,找到最短路径上的k条边即可。

3. 代码如下:

import heapq
from typing import List


class Solution:
    # 堆优化版的dijkstra算法求解从1号点到其余点的最短距离
    def dijkstra(self, n: int, dis: List[int], g: List[List[int]]):
        vis = [0] * (n + 10)
        q = list()
        heapq.heappush(q, (0, 1))
        dis[1] = 0
        while q:
            p = heapq.heappop(q)
            if vis[p[1]] == 1: continue
            vis[p[1]] = 1
            for next in g[p[1]]:
                if dis[next[0]] > dis[p[1]] + next[1]:
                    dis[next[0]] = dis[p[1]] + next[1]
                    heapq.heappush(q, (dis[next[0]], next[0]))

    def dfs(self, u: int, k: int, vis: List[int], dis: List[int], g: List[List[int]], res: List[int]):
        vis[u] = 1
        for next in g[u]:
            # 当前点next[0]是由u更新过来的并且next[0]还未访问过
            if vis[next[0]] == 0 and dis[next[0]] == dis[u] + next[1]:
                if len(res) < k:
                    # next[2]为当前边的编号
                    res.append(next[2])
                    self.dfs(next[0], k, vis, dis, g, res)

    def process(self):
        n, m, k = map(int, input().split())
        g = [list() for i in range(n + 10)]
        for i in range(1, m + 1):
            x, y, z = map(int, input().split())
            # 因为最终需要输出边的编号需要存储多一个边的编号的信息
            g[x].append((y, z, i))
            g[y].append((x, z, i))
        INF = 10 ** 18
        dis = [INF] * (n + 10)
        self.dijkstra(n, dis, g)
        res = list()
        # 使用vis列表标记dfs的过程中哪些点已经被访问了, 每一个点只能够被访问一次
        vis = [0] * (n + 10)
        self.dfs(1, k, vis, dis, g, res)
        print(len(res))
        for x in res:
            print(x, end=" ")


if __name__ == '__main__':
    Solution().process()
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是一个简单的结构的 C++ 实现,包括节点的增加、删除和查找功能: ```c++ #include<iostream> #include<vector> using namespace std; struct TreeNode{ int val; vector<TreeNode*> children; TreeNode(int x): val(x){} }; class Tree{ public: Tree(){ root = NULL; } // 添加节点 void addNode(int parent_val, int val){ TreeNode* new_node = new TreeNode(val); if(!root){ root = new_node; return; } TreeNode* parent = findNode(root, parent_val); parent->children.push_back(new_node); } // 删除节点 void deleteNode(int val){ TreeNode* node = findNode(root, val); if(!node){ cout << "Node not found!" << endl; return; } if(node == root){ delete root; root = NULL; return; } TreeNode* parent = findParent(root, val); for(int i=0; i<parent->children.size(); i++){ if(parent->children[i]->val == val){ parent->children.erase(parent->children.begin() + i); break; } } delete node; } // 查找节点 TreeNode* findNode(TreeNode* node, int val){ if(!node) return NULL; if(node->val == val) return node; for(int i=0; i<node->children.size(); i++){ TreeNode* found = findNode(node->children[i], val); if(found) return found; } return NULL; } private: TreeNode* root; // 查找节点的父节点 TreeNode* findParent(TreeNode* node, int val){ if(!node || node->val == val) return NULL; for(int i=0; i<node->children.size(); i++){ if(node->children[i]->val == val) return node; TreeNode* parent = findParent(node->children[i], val); if(parent) return parent; } return NULL; } }; int main(){ Tree t; t.addNode(0, 1); t.addNode(1, 2); t.addNode(1, 3); t.addNode(2, 4); t.addNode(2, 5); t.addNode(3, 6); TreeNode* found = t.findNode(t.root, 2); if(found) cout << found->val << endl; t.deleteNode(2); found = t.findNode(t.root, 2); if(found) cout << found->val << endl; else cout << "Node not found!" << endl; return 0; } ``` 这个实现中,节点的结构体包括节点值和一个指向其所有子节点的向量。类中实现了添加节点、删除节点和查找节点的方法。其中,查找节点的方法使用了递归实现。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值