bzoj 2069 [ POI 2004 ] ZAW —— 多起点最短路 + 二进制划分

本文探讨了在解决特定类型的最短路径问题时的一种优化策略,通过二进制划分起点和终点,避免了多次运行Dijkstra算法的效率瓶颈。特别地,文章详细介绍了如何在包含特定节点(如节点1)的图中,通过枚举和多起点最短路径算法来寻找全局最优解。

题目:https://www.lydsy.com/JudgeOnline/problem.php?id=2069

首先,对于和 1 相连的点,一定是从某个点出发,回到另一个点;

所以需要枚举起点和终点,但做 n 遍 dijkstra 不太可行;

可以进行多起点最短路,一次知道了以一些点作为起点、另一些点作为终点的答案;

于是问题是如何划分起点和终点,使一定能找到最优解;

二进制划分,枚举每一位,这一位是 0/1 分成两部分,那么任意不同的两个数一定某一次被分到了不同的集合;

具体做法可以是从 1 出发,不让起点回到 1,不让终点来到 1,最后看看终点的 dis;

也可以干脆去掉 1,起点的 dis 值是从 1 到它的距离;

注意分成两部分后要分别跑一遍是起点和终点的。

代码如下:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
int const maxn=5005,maxm=20005,inf=0x3f3f3f3f;
int n,m,hd[maxn],ct,to[maxm],nxt[maxm],w[maxm],dis[maxn],mx,ans=inf;
int son[maxn],ss,wt[maxn],wc[maxn];
bool vis[maxn],st[maxn],ed[maxn];
priority_queue<pair<int,int> >q;
void add(int x,int y,int z){to[++ct]=y; nxt[ct]=hd[x]; w[ct]=z; hd[x]=ct;}
void dijkstra()
{
    while(q.size())q.pop();
    memset(vis,0,sizeof vis);
    memset(dis,0x3f,sizeof dis);
    dis[1]=0; q.push(make_pair(0,1));
//    for(int i=1,x;i<=ss;i++)
//        if(st[x=son[i]])dis[x]=wt[x],q.push(make_pair(-dis[x],x));
//    vis[1]=1;
    while(q.size())
    {
        int x=q.top().second; q.pop();
        if(vis[x])continue; vis[x]=1;
        for(int i=hd[x],u;i;i=nxt[i])
        {
            if(vis[u=to[i]]||st[x]&&u==1||x==1&&ed[u])continue;
//            if(vis[u=to[i]])continue;
            if(dis[u]>dis[x]+w[i])
                dis[u]=dis[x]+w[i],q.push(make_pair(-dis[u],u));
        }
    }
    for(int i=1,x;i<=ss;i++)
        if(ed[x=son[i]])ans=min(ans,dis[x]+wc[x]);
}
int main()
{
    scanf("%d%d",&n,&m);
    int tmp=n; while(tmp)mx++,tmp/=2;
    for(int i=1,x,y,a,b;i<=m;i++)
    {
        scanf("%d%d%d%d",&x,&y,&a,&b);
        add(x,y,a); add(y,x,b);
        if(x==1)son[++ss]=y,wt[y]=a,wc[y]=b;
        if(y==1)son[++ss]=x,wt[x]=b,wc[x]=a;
    }
    for(int i=0;i<mx;i++)
    {
        memset(st,0,sizeof st);
        memset(ed,0,sizeof ed);
        for(int j=1;j<=ss;j++)
            if(son[j]&(1<<i))st[son[j]]=1;
            else ed[son[j]]=1;
        dijkstra();
        for(int j=1,x;j<=ss;j++)
            if(st[x=son[j]])st[x]=0,ed[x]=1;
            else if(ed[x])ed[x]=0,st[x]=1;
        dijkstra();
    }
    printf("%d\n",ans);
    return 0;
}

 

转载于:https://www.cnblogs.com/Zinn/p/9489380.html

### BZOJ1728 Two-Headed Cows (双头牛) 的解题思路 #### 题目概述 BZOJ1728 是一道经典的图论问题,题目描述了一群双头牛之间的关系网络。每只双头牛可以看作是一个节点,而它们的关系则构成了边。目标是从这些关系中找出满足特定条件的大子集。 此问题的核心在于利用 **二分查找** 和 **染色法** 来验证是否存在符合条件的子图结构[^1]。 --- #### 解题核心概念 ##### 1. 图模型构建 该问题可以通过无向图建模,其中每个顶点代表一只双头牛,边表示两只双头牛之间存在某种关联。终的目标是在这个图中找到大的独立集合(Independent Set),即任意两个顶点都不相连的一组顶点[^2]。 ##### 2. 二分查找的应用 为了高效求解大独立集大小 \( k \),采用二分策略来逐步逼近优解。具体来说,在区间 [0, n] 中通过不断调整上下界寻找可能的大值 \( k \)[^3]。 ##### 3. 染色法验证可行性 对于当前假设的大独立集大小 \( mid \),尝试从原图中选取恰好 \( mid \) 个顶点构成候选集合,并检查其是否形成合法的独立集。这一过程通常借助 BFS 或 DFS 实现,同时配合颜色标记技术区分已访问状态以及检测冲突情况[^4]。 以下是基于 Python 的伪代码实现: ```python from collections import deque def bfs_coloring(graph, start_node): queue = deque() color_map = {} # 初始化起点的颜色为 0 color_map[start_node] = 0 queue.append(start_node) while queue: current = queue.popleft() for neighbor in graph[current]: if neighbor not in color_map: # 给邻居分配相反的颜色 color_map[neighbor] = 1 - color_map[current] queue.append(neighbor) elif color_map[neighbor] == color_map[current]: return False # 如果发现相邻节点有相同颜色,则无法完成有效染色 return True def is_possible_to_select_k(graph, nodes_count, target_size): from itertools import combinations all_nodes = list(range(nodes_count)) possible_combinations = combinations(all_nodes, target_size) for subset in possible_combinations: subgraph = {node: [] for node in subset} valid_subset = True for u in subset: for v in graph[u]: if v in subset and v != u: subgraph[u].append(v) # 对子图进行染色测试 colors_used = set() coloring_success = True for node in subset: if node not in colors_used: success = bfs_coloring(subgraph, node) if not success: coloring_success = False break if coloring_success: return True # 找到一个有效的组合即可返回成功标志 return False def binary_search_max_independent_set(graph, total_nodes): low, high = 0, total_nodes best_result = 0 while low <= high: mid = (low + high) // 2 if is_possible_to_select_k(graph, total_nodes, mid): best_result = mid low = mid + 1 else: high = mid - 1 return best_result ``` --- #### 复杂度分析 上述算法的时间复杂度主要取决于以下几个方面: - 枚举所有可能的子集规模:\( O(\binom{n}{k}) \), 其中 \( k \) 表示当前试探的独立集大小。 - 子图构造与染色检验操作:每次调用 `bfs_coloring` 函数需遍历整个子图,坏情况下时间开销接近线性级别 \( O(k^2) \). 综合来看整体效率较高但仍有优化空间[^5]. --- #### 总结 通过对 BZOJ1728 进行深入剖析可知,合理运用二分加染色的方法能够显著提升解决问题的能力。这种方法不仅适用于本题场景下寻找大独立集的任务需求,同时也可推广至其他相似类型的 NP 完全难题处理之中[^6]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值