[bzoj4378][POI2015]Logistyka

本文针对POI2015物流问题提供了一种解决方案,通过维护一个序列并支持特定操作来解答询问。文章详细介绍了输入输出格式、样例及分析过程。

4378: [POI2015]Logistyka

Time Limit: 20 Sec Memory Limit: 256 MB
Submit: 226 Solved: 118
[Submit][Status][Discuss]
Description

维护一个长度为n的序列,一开始都是0,支持以下两种操作:
1.U k a 将序列中第k个数修改为a。
2.Z c s 在这个序列上,每次选出c个正数,并将它们都减去1,询问能否进行s次操作。
每次询问独立,即每次询问不会对序列进行修改。

Input

第一行包含两个正整数n,m(1<=n,m<=1000000),分别表示序列长度和操作次数。
接下来m行为m个操作,其中1<=k,c<=n,0<=a<=10^9,1<=s<=10^9。

Output

包含若干行,对于每个Z询问,若可行,输出TAK,否则输出NIE。

Sample Input

3 8

U 1 5

U 2 7

Z 2 6

U 3 1

Z 2 6

U 2 2

Z 2 6

Z 2 1

Sample Output

NIE

TAK

NIE

TAK

对于每一个询问可以分成这样几种情况讨论:
sum表示权值>=s的个数,num表示权值<s的元素的权值和。
①:sum>=c 这种情况肯定是TAK
②:sum<c&&num>=(csum)s这种情况也肯定是TAK
第二种情况为什么是呢?是因为当num>=(csum)s的时候,说明这时候元素的个数肯定<csum所以一定可以。
最后剩下的一种情况就是NIE了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
const int N=1000010;
int n,m,a[N],o[N],b[N];
struct Q{int kind,x,y;}q[N];
struct S{LL v;int sum;}tr[N<<2];
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;
}
#define mid (l+r)/2
#define L k<<1,l,mid
#define R k<<1|1,mid+1,r
inline S update(S x,S y){
    S ans;
    ans.sum=x.sum+y.sum;
    ans.v=x.v+y.v;
    return ans;
}
inline void insert(int k,int l,int r,int x,int kind){
    if(l==r){
        tr[k].v+=(LL)o[l]*kind;
        tr[k].sum+=kind;
        return ;
    }
    if(x<=mid) insert(L,x,kind);
    else insert(R,x,kind);
    tr[k]=update(tr[k<<1],tr[k<<1|1]);
}
inline S query(int k,int l,int r,int x,int y){
    if(y<x) return (S){0,0};
    S ans1,ans2;
    bool f1=false,f2=false;
    if(x<=l&&y>=r) return tr[k];
    if(x<=mid) ans1=query(L,x,y),f1=true;
    if(y>mid) ans2=query(R,x,y),f2=true;
    if(f1&&f2) return update(ans1,ans2);
    else return f1?ans1:ans2;
}
int main(){
    int i,x,y;
    n=in();m=in();
    for(i=1;i<=m;++i){
        char ch=getchar();
        while(ch!='U'&&ch!='Z') ch=getchar();
        if(ch=='U') q[i].kind=1;
        if(ch=='Z') q[i].kind=2;
        q[i].x=in();q[i].y=in();
        a[i]=q[i].y;
    }
    sort(a+1,a+m+1);
    int size=unique(a+1,a+m+1)-a-1;
    for(i=1;i<=m;++i){
        int now=q[i].y;
        q[i].y=lower_bound(a+1,a+size+1,q[i].y)-a;
        o[q[i].y]=now;
    }
    for(i=1;i<=m;++i){
        x=q[i].x;y=q[i].y;
        if(q[i].kind==1){
            if(b[x]) insert(1,1,size,b[x],-1);
            b[x]=y; insert(1,1,size,b[x],1);
        }
        if(q[i].kind==2){
            S now=query(1,1,size,y,size);
            if(now.sum>=x){
                puts("TAK");
                continue;
            }
            int remain=x-now.sum,flag=0;
            now=query(1,1,size,1,y-1);
            if(now.v>=(LL)remain*(LL)o[y]) flag=1;
            if(flag) puts("TAK");
            else puts("NIE"); 
        }
    }
}
### 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]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值