Question

考虑包含 N 节点和 M 边缘的无向图。每个边 M _i 都有一个与之关联的整数代价 C _i 。

路径的代价是一对节点 A 和 B 之间路径中每个边缘成本的按位OR。换句话说，如果路径包含边 M ₁ ， M ₂ ，...， M _k 然后该路径的惩罚是 C ₁ 或 C ₂ < / em> OR ...或 C _k 。

给定一个图形和两个节点 A 和 B ，找到 A 和 B 之间的路径尽可能少的罚款并打印罚款;如果不存在此类路径，请打印−1以指示没有从 A 到 B 的路径。

注意：允许循环和多个边缘。

约束：

1≤Ñ≤10³

1≤中号≤10³

1≤ C <子> I ＆LT; 1024

1≤Ú<子> I ， V <子> I ≤Ñ

1≤ A ，乙≤Ñ

A ≠乙

这个问题是在比赛中被问到的，而且我已经完成了教程但却无法得到它。任何人都可以解释或给出答案如何进行？

Answer 1

可以通过遵循递归公式使用动态编程来解决：

D(s,0) = true
D(v,i) = false OR D(v,i) OR { D(u,j) | (u,v) is an edge, j or c(u,v) = i }

s是源节点。

这个想法是D(v,i) == true当且仅当有s到v的路径时，权重正好为i。
现在，您在动态编程中迭代地修改图形，直到它收敛（最多在n次迭代之后）。
这基本上是Bellman-Ford algorithm的变体。为解决方案创建DP表后，最小路径为min { x | D(t,x) = true}（其中t为目标节点）。

时间复杂度为O(m*n*log_2(R))，其中R是允许的最大权重（在您的情况下为1024）。

Answer 2

您要找的是Dijkstra's Algorithm。不是为每个节点添加权重，而应该对其进行OR运算。

因此，伪代码如下（从维基百科示例中修改）：

 1  function Dijkstra(Graph, source):
 2
 3      create vertex set Q
 4
 5      for each vertex v in Graph:             // Initialization
 6          dist[v] ← INFINITY                  // Unknown distance from source to v
 7          prev[v] ← UNDEFINED                 // Previous node in optimal path from source
 8          add v to Q                          // All nodes initially in Q (unvisited nodes)
 9
10      dist[source] ← 0                        // Distance from source to source
11      
12      while Q is not empty:
13          u ← vertex in Q with min dist[u]    // Source node will be selected first
14          remove u from Q 
15          
16          for each neighbor v of u:           // where v is still in Q.
17              alt ← dist[u] OR length(u, v)
18              if alt < dist[v]:               // A shorter path to v has been found
19                  dist[v] ← alt 
20                  prev[v] ← u 
21
22      return dist[], prev[]

注意第17行的OR。

Answer 3

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <ll,ll > pr;
vector <pr> adj[10005];
bool visited[10005][10005];
int main(){
    ll n,m;
    scanf("%lld%lld",&n,&m);
    for(ll i=1;i<=m;i++){
        ll u,v,w;
        scanf("%lld%lld%lld",&u,&v,&w);
        adj[u].push_back(make_pair(v,w));
        adj[v].push_back(make_pair(u,w));
    }
    ll source,destination;
    scanf("%lld%lld",&source,&destination);
    queue<ll> bfsq;
    bfsq.push(source);// source into queue
    bfsq.push(0);// 
    while(!bfsq.empty()){
    ll u=bfsq.front();
        bfsq.pop();
        ll cost=bfsq.front();
        bfsq.pop();
        visited[u][cost]=true;
        for(ll i=0;i<adj[u].size();i++){
          ll  v=adj[u][i].first;// neighbor of u is v
          ll  w2=adj[u][i].second;//// u is connected to v with this cost
          if(visited[v][w2|cost]==false){
            visited[v][w2|cost]=true;
            bfsq.push(v);
            bfsq.push(w2|cost);


          }
        }
    }
    ll ans=-1LL;
    for(ll i=0;i<1024;i++){
        if(visited[destination][i]==true){
            ans=i;
            break;
        }
    }
    printf("%lld\n",ans);
    return 0;

}

加权图

3 个答案: