[bzoj4383][POI2015]Pustynia

本文解析了POI2015竞赛题目Pustynia,介绍了如何通过拓扑排序解决给定的序列问题。利用线段树优化建图过程,确保点的权值符合题目要求。

4383: [POI2015]Pustynia

Time Limit: 10 Sec Memory Limit: 128 MBSec Special Judge
Submit: 162 Solved: 58
[Submit][Status][Discuss]
Description

给定一个长度为n的正整数序列a,每个数都在1到10^9范围内,告诉你其中s个数,并给出m条信息,每条信息包含三个数l,r,k以及接下来k个正整数,表示a[l],a[l+1],…,a[r-1],a[r]里这k个数中的任意一个都比任意一个剩下的r-l+1-k个数大(严格大于,即没有等号)。
请任意构造出一组满足条件的方案,或者判断无解。

Input

第一行包含三个正整数n,s,m(1<=s<=n<=100000,1<=m<=200000)。
接下来s行,每行包含两个正整数p[i],di,表示已知a[p[i]]=d[i],保证p[i]递增。
接下来m行,每行一开始为三个正整数l[i],r[i],ki,接下来k[i]个正整数x[1],x[2],…,xk[i],表示这k[i]个数中的任意一个都比任意一个剩下的r[i]-l[i]+1-k[i]个数大。Σk <= 300,000

Output

若无解,则输出NIE。
否则第一行输出TAK,第二行输出n个正整数,依次输出序列a中每个数。

Sample Input

5 2 2

2 7

5 3

1 4 2 2 3

4 5 1 4

Sample Output

TAK

6 7 1000000000 6 3

对于每一个限制,都可以从大的数向每一个小的数连一条单向边,那么最后的大小关系就拓扑排序一遍就行了。
这样建图的话点数是 n2 的。用线段树优化一下建图就好了。
这道题有一个坑点,就是点的权值要小于 1e9

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1e9;
const int N=100010;
const int M=2000010;
bool flag[M];
struct S{int st,en,va;}aa[M];
int n,T,m,v[M],tot,point[M],next[M],ru[M],mp[N],siz,K,num,c[N],d[N],l[M];
inline int in(){
    int x=0;char ch=getchar();
    while(ch<'0'||ch>'9') ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x;
}
inline void add(int x,int y,int z){
    next[++tot]=point[x];point[x]=tot;
    aa[tot].st=x;aa[tot].en=y;aa[tot].va=z;++ru[y];
}
#define mid (l+r)/2
#define L k<<1,l,mid
#define R k<<1|1,mid+1,r
inline void build(int k,int l,int r){
    siz=max(siz,k);
    v[k]=maxn;
    if(l==r){
        mp[l]=k;
        return ;
    }
    add(k,k<<1,0);
    add(k,k<<1|1,0);
    build(L);build(R);
}
inline void insert(int k,int l,int r,int x,int y,int z){
    if(x<=l&&y>=r){
        add(z,k,0);
        return ;
    }
    if(x<=mid) insert(L,x,y,z);
    if(y>mid) insert(R,x,y,z);
}
inline void Tsort(int x){
    int i,h=1,t=1,u;
    l[t]=x;
    while(h<=t){
        u=l[h];flag[u]=true;
        for(i=point[u];i;i=next[i]){
            if(!(--ru[aa[i].en])) l[++t]=aa[i].en;
            v[aa[i].en]=min(v[aa[i].en],v[u]-aa[i].va);
        }
        ++h;
    }
}
int main(){
    int i,x,y,z;
    n=in();T=in();m=in();
    build(1,1,n);
    for(i=1;i<=T;++i){
        x=in();y=in();
        c[i]=x;d[i]=y;
        v[mp[x]]=y;
    }
    while(m--){
        x=in();y=in();K=in();
        int pre=x;v[num+siz+1]=maxn;
        for(++num,i=1;i<=K;++i){
            z=in();
            add(mp[z],siz+num,1);
            if(z>pre) insert(1,1,n,pre,z-1,siz+num);
            pre=z+1;
        }
        if(y>=pre) insert(1,1,n,pre,y,siz+num);
    }
    Tsort(1);
    bool mark=true;
    for(i=1;i<=n&&mark;++i)
        if(!flag[mp[i]]||v[mp[i]]<=0||v[mp[i]]>maxn) mark=false; 
    for(i=1;i<=T&&mark;++i)
        if(v[mp[c[i]]]!=d[i]) mark=false;
    if(!mark){
        puts("NIE");
        return 0;
    }
    for(puts("TAK"),i=1;i<=n;++i)
        printf("%d ",v[mp[i]]);
    puts("");
}
### NOIP2015 运输计划 BZOJ4326 题解分析 #### 问题背景 该问题是经典的图论优化问题之一,主要考察树结构上的路径操作以及高效的数据处理能力。题目要求在一个由 $n$ 个节点组成的无向连通树中找到最优的一条边将其改造为虫洞(通过此边不需要耗费时间),从而使得给定的 $m$ 条运输路径中的最长耗时最小化。 --- #### 解决方案概述 解决这一问题的核心在于利用 **二分答案** 和 **树上差分技术** 的组合来实现高效的计算过程。以下是具体的技术细节: 1. **二分答案**: 设当前目标是最小化的最大路径长度为 $T_{\text{max}}$。我们可以通过二分的方式逐步逼近最终的结果。每次尝试验证是否存在一种方式将某条边改为虫洞后使所有路径的最大值不超过当前设定的目标值 $mid$[^1]。 2. **路径标记与统计**: 使用树上差分的思想对每一条路径进行标记并快速统计受影响的情况。假设两点之间的最近公共祖先 (Lowest Common Ancestor, LCA) 是 $r = \text{lca}(u_i, v_i)$,则可以在三个位置分别施加影响:增加 $(u_i + 1), (v_i + 1)$ 同时减少 $(r - 2)$。这种操作能够有效覆盖整条路径的影响范围,并便于后续统一查询和判断[^1]。 3. **数据结构支持**: 结合线段树或者 BIT (Binary Indexed Tree),可以进一步加速区间修改和单点查询的操作效率。这些工具帮助我们在复杂度范围内完成大量路径的同时更新和检索需求[^2]。 4. **实际编码技巧**: 实现过程中需要注意一些边界条件和技术要点: - 正确维护 DFS 序列以便映射原树节点到连续编号序列; - 准备好辅助函数用于快速定位 LCA 节点及其对应关系; - 编码阶段应特别留意变量初始化顺序及循环终止逻辑以防潜在错误发生。 下面给出一段基于上述原理的具体 Python 实现代码作为参考: ```python from collections import defaultdict, deque class Solution: def __init__(self, n, edges): self.n = n self.graph = defaultdict(list) for u, v, w in edges: self.graph[u].append((v, w)) self.graph[v].append((u, w)) def preprocess(self): """Preprocess the tree to get dfs order and lca.""" pass def binary_search_answer(self, paths): low, high = 0, int(1e9) best_possible_time = high while low <= high: mid = (low + high) // 2 if self.check(mid, paths): # Check feasibility with current 'mid' best_possible_time = min(best_possible_time, mid) high = mid - 1 else: low = mid + 1 return best_possible_time def check(self, limit, paths): diff_array = [0]*(self.n+1) for path_start, path_end in paths: r = self.lca(path_start, path_end) # Apply difference on nodes based on their relationship. diff_array[path_start] += 1 diff_array[path_end] += 1 diff_array[r] -= 2 suffix_sum = [sum(diff_array[:i]) for i in range(len(diff_array)+1)] # Verify whether any edge can be modified within given constraints. possible_to_reduce_max = False for node in range(1, self.n+1): parent_node = self.parent[node] if suffix_sum[node]-suffix_sum[parent_node]>limit: continue elif not possible_to_reduce_max: possible_to_reduce_max=True return possible_to_reduce_max # Example usage of class methods would follow here... ``` --- #### 总结说明 综上所述,本题的关键突破点在于如何巧妙运用二分策略缩小搜索空间,再辅以恰当的树形结构遍历技术和差分手段提升整体性能表现。这种方法不仅适用于此类特定场景下的最优化求解任务,在更广泛的动态规划领域也有着广泛的应用前景[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值