BZOJ2654 - tree

本文介绍了一种使用二分搜索算法求解包含特定数量白边的最小生成树问题的方法,通过给白边附加额外权重,确保生成树中白边数量可控,最终找到满足条件的最小生成树。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Portal

Description

给出一个无向连通图\((V,E)\)\(|V|\leq5\times10^4,|E|\leq10^5\)),边分为白边和黑边,边权不超过\(100\)。求该无向图的恰好包含\(k\)条白边的最小生成树的权值。保证有解。

Solution

二分。
我们给所有白边一个额外权值\(w'\)。显然MST中白边的数量与\(w'\)负相关,于是我们二分这个\(w'\)
可以证明,加上\(w'\)后的一个包含\(x\)条白边的MST,就是原图中包含\(x\)条白边的最小生成树。因为所有包含\(x\)条白边的生成树在此时的权值都加上了\(w'x\),所以其在原图中仍然最小。那么我们只要找到一棵包含\(k\)条边的生成树即可。
不过对于一个\(w'\),不同的MST包含的白边数可能不同。我们可以优先白边求一个MST,其包含\(kR\)条白边;优先黑边求一个MST,其包含\(kL\)条白边。那么该图的所有MST中的白边数都在\([kL,kR]\)区间内,且每种白边数的MST都存在1。那么当\(k\in[kL,kR]\)时我们也找到了一棵包含\(k\)条边的生成树。

时间复杂度\(O(log(100|E|)\cdot |E|\log |E|)=O(|E|log^2|E|)\)

Code

//tree
#include <algorithm>
#include <cstdio>
using namespace std;
const double EPS=1e-4;
inline char gc()
{
    static char now[1<<16],*s,*t;
    if(s==t) {t=(s=now)+fread(now,1,1<<16,stdin); if(s==t) return EOF;}
    return *s++;
}
inline int read()
{
    int x=0; char ch=gc();
    while(ch<'0'||'9'<ch) ch=gc();
    while('0'<=ch&&ch<='9') x=x*10+ch-'0',ch=gc();
    return x;
}
inline bool equal(double x,double y) {return -EPS<x-y&&x-y<=EPS;}
const int N=5e4+10;
int n,m,k;
struct edge{int u,v,w0,c; double w;} ed[N*2];
double ans;
bool cmpW0(edge x,edge y) {return equal(x.w,y.w)?x.c<y.c:x.w<y.w;}
bool cmpW1(edge x,edge y) {return equal(x.w,y.w)?x.c>y.c:x.w<y.w;}
double res;
int pre[N];
int find(int x) {return x==pre[x]?x:pre[x]=find(pre[x]);}
int Kruskal()
{
    res=0; int kCnt=0,trCnt=0;
    for(int i=1;i<=n;i++) pre[i]=i;
    for(int i=1;i<=m;i++)
    {
        int u=ed[i].u,v=ed[i].v;
        if(find(u)!=find(v))
        {
            res+=ed[i].w; if(ed[i].c==0) kCnt++; trCnt++;
            pre[find(u)]=find(v);
        }
        if(trCnt==n-1) return kCnt;
    }
}
void bSearch(double L,double R)
{
    if(ans) return;
    double mid=(L+R)/2;
    for(int i=1;i<=m;i++) if(ed[i].c==0) ed[i].w=ed[i].w0-mid;
    int kL,kR;
    sort(ed+1,ed+m+1,cmpW0); kR=Kruskal();
    sort(ed+1,ed+m+1,cmpW1); kL=Kruskal();
    if(kL<=k&&k<=kR) {ans=res+k*mid; return;}
    if(k<kL) bSearch(L,mid);
    if(kR<k) bSearch(mid,R);
}
int main()
{
    n=read(),m=read(),k=read();
    for(int i=1;i<=m;i++)
    {
        ed[i].u=read()+1,ed[i].v=read()+1;
        ed[i].w=ed[i].w0=read(),ed[i].c=read();
    }
    bSearch(-10,10);
    printf("%.0lf\n",ans);
    return 0;
}

P.S.

说是二分\(100|E|\)其实二分\([-10,10]\)就能过,并没有特别极限的数据。
或许只在\([-10,10]\)里二分整数也可以,因为如果二分到小数就没有权值相同的边,一定有\(kL=kR\)


  1. 权值相同的生成树可以通过加边\((u,v)\)再删掉路径\((u,v)\)上的一条权值相同的边来互相转化。那么我们可以添加白边再删掉权值相同的黑边。(以上均为口胡,没有严谨证明)

转载于:https://www.cnblogs.com/VisJiao/p/BZOJ2654.html

### BZOJ 2905 背单词 解决方案 #### 问题分析 BZOJ 2905 是一道涉及字符串匹配和动态规划的经典题目。该题的核心在于通过构建 **AC 自动机** 和利用 **线段树** 来优化状态转移过程,从而高效解决多个字符串之间的关系及其权值计算。 以下是基于已有引用内容以及专业知识对该问题的解答: --- #### 数据结构与算法设计 1. 构建 AC 自动机: 使用 Trie 树存储所有输入的字符串,并在此基础上建立 fail 指针构成 AC 自动机。这一步可以快速定位某个字符串是否为另一个字符串的后缀[^3]。 2. 建立 Fail 树: 将 AC 自动机中的节点按照 fail 指针的关系构建成一棵树(称为 Fail 树)。Fail 树上的父子关系表示某些字符串之间可能存在后缀关系[^3]。 3. 处理 DFS 序列: 对 Fail 树进行深度优先遍历 (DFS),并记录每个节点在 DFS 过程中的进入时间和退出时间。这些时间戳可以帮助我们将子树范围映射成一段连续区间[^3]。 4. 动态规划与线段树优化: 定义 `dp[i]` 表示以第 `i` 个字符串结尾时所能获得的最大收益。对于每个字符串,在其对应 Trie 节点上查找能够成为其后缀的所有祖先节点的最大收益值,并将其加到当前字符串的权值之上。 此处的关键操作是在沿着 Trie 树路径向上回溯的同时,查询 Fail 树中某棵子树范围内已知最大收益值。这一部分可以通过线段树实现高效的单点修改和区间最值查询[^3]。 --- #### 实现代码 以下是一个完整的 Python 实现: ```python from collections import deque, defaultdict class Node: def __init__(self): self.children = {} self.fail = None self.output = [] self.id = -1 self.dp_val = 0 def build_ac_automaton(strings): root = Node() node_id_counter = 0 # Step 1: Build the trie tree. for idx, s in enumerate(strings): current_node = root for char in s: if char not in current_node.children: new_node = Node() current_node.children[char] = new_node current_node = current_node.children[char] current_node.output.append(idx) queue = deque([root]) while queue: parent = queue.popleft() for child_char, child in parent.children.items(): if parent is root: child.fail = root else: state = parent.fail while state and child_char not in state.children: state = state.fail if state: child.fail = state.children[child_char] else: child.fail = root queue.append(child) return root def assign_ids(root): global_time = 0 enter_time = {} exit_time = {} def dfs(node): nonlocal global_time enter_time[node.id] = global_time global_time += 1 for next_node in node.children.values(): dfs(next_node) exit_time[node.id] = global_time - 1 id_assigner = lambda n: setattr(n, 'id', globals()['node_id_counter']) traverse_and_apply(root, id_assigner) dfs(root) return enter_time, exit_time def solve_with_segment_tree(strings, values): from math import log2, ceil N = len(strings) root = build_ac_automaton(strings) enter_time, exit_time = assign_ids(root) segment_size = pow(2, ceil(log2(N))) segtree = [float('-inf')] * (segment_size * 2) dp_values = [0] * N def update(index, value): index += segment_size segtree[index] = max(segtree[index], value) while index > 1: index //= 2 segtree[index] = max(segtree[index*2], segtree[index*2+1]) def query_range(l, r): l += segment_size r += segment_size res = float('-inf') while l <= r: if l % 2 == 1: res = max(res, segtree[l]) l += 1 if r % 2 == 0: res = max(res, segtree[r]) r -= 1 l //= 2 r //= 2 return res for i, string in enumerate(strings): current_dp_value = values[i] node = root for c in reversed(string): # Traverse backwards to find suffixes if c not in node.children: break node = node.children[c] ancestor_start = enter_time.get(node.id, -1) ancestor_end = exit_time.get(node.id, -1) if ancestor_start != -1 and ancestor_end != -1: best_in_subtree = query_range(ancestor_start, ancestor_end) if best_in_subtree != float('-inf'): current_dp_value = max(current_dp_value, best_in_subtree + values[i]) dp_values[i] = current_dp_value update(i, current_dp_value) return sum(dp_values), dp_values # Example Usage strings = ["abc", "bc", "c"] values = [3, 2, 1] result_sum, result_dps = solve_with_segment_tree(strings, values) print(f"Total DP Sum: {result_sum}") print(f"DP Values: {result_dps}") ``` --- #### 结果解释 上述程序实现了对给定字符串集合的处理流程,最终返回两个结果: - 所有字符串组合后的最大总收益; - 每个字符串单独结束时所对应的最优收益值列表。 此方法的时间复杂度接近于 \(O(\text{总串长} \times \log N)\)[^3],适用于较大规模的数据集。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值