bzoj 3389 [Usaco2004 Dec]Cleaning Shifts安排值班

该问题描述了一天中需要安排奶牛在不同时间段值班以保持牛棚清洁,每只奶牛有自己的空闲时段。目标是最少动用奶牛数量。如果无法安排,输出-1。可以通过将问题转化为最短路问题并使用堆优化的Dijkstra算法求解。

Description
一天有T(1≤T≤10^6)个时段.约翰正打算安排他的N(1≤N≤25000)只奶牛来值班,打扫打扫牛棚卫生.每只奶牛都有自己的空闲时间段Si,Ei,只能把空闲的奶牛安排出来值班.而且,每个时间段必需有奶牛在值班. 那么,最少需要动用多少奶牛参与值班呢?如果没有办法安排出合理的方案,就输出-1.
Input

第1行:N,T.
第2到N+1行:Si,Ei.

Output

最少安排的奶牛数.

Sample Input
3 10
1 7
3 6
6 10
Sample Output
2
样例说明

奶牛1和奶牛3参与值班即可.

这题可以抽象成最短路,从0到T。连边的方式可以自己先琢磨琢磨,然后跑一遍堆优化的dij就可以了。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#define ll long long
using namespace std;
int n,T,x,y,t,w,ty,tot;
int head[1000005],Next[1030005],to[1030005],len[1030005];
int pos[1000005],heap[1000005],dis[1000005];
void add(int x,int y,int z)
{
    tot++;
    Next[tot]=head[x];
    to[tot]=y;
    len[tot]=z;
    head[x]=tot;
}
void up(int id)
{
    while(id/2>=1)
    {
        int x=heap[id];
        int y=heap[id/2];
        if(dis[x]<dis[y])
        {
            swap(heap[id],heap[id/2]);
            swap(pos[x],pos[y]);
            id=id/2;
        }
        else break;
    }
}
void down(int id)
{
    int j;
    while(id*2<=ty) 
    {
        int x=heap[id*2];
        int y=heap[id*2+1];
        if(id*2+1>ty||dis[x]<dis[y]) j=id*2; else j=id*2+1;
        x=heap[id];
        y=heap[j];
        if(dis[x]>dis[y]) 
        {
            swap(heap[id],heap[j]);
            swap(pos[x],pos[y]);
            id=j;
        }
        else break;
    }
}               
void dij()
{
    for(int i=1;i<=T;i++) dis[i]=1e9;
    dis[0]=0;
    ty=1;
    heap[1]=0;
    pos[0]=1;
    while(ty>0)
    {
        int y=heap[1];
        pos[y]=0;
        swap(heap[1],heap[ty]);
        swap(pos[heap[1]],pos[heap[ty]]);
        ty--;
        down(1);
        for(int i=head[y];i!=-1;i=Next[i]) 
        if(dis[y]+len[i]<dis[to[i]]) 
        {
            dis[to[i]]=dis[y]+len[i];
            if(pos[to[i]]==0) 
            {
                ty++;
                heap[ty]=to[i];
                pos[to[i]]=ty;
            }
            up(pos[to[i]]);
        } 
    }
}
int main()
{
    cin>>n>>T;
    for(int i=0;i<=T;i++) head[i]=-1;
    for(int i=1;i<=T;i++) add(i,i-1,0);
    for(int i=1;i<=n;i++) 
    {
        scanf("%d%d",&x,&y);
        add(x-1,y,1);
    }
    dij();
    if(dis[T]==1e9) cout<<"-1"; else cout<<dis[T];
    return 0;
}
### 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]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值