【BZOJ 4069】 [Apio2015]巴厘岛的雕塑

本文详细解析了一道名为'巴厘岛的雕塑'的算法题目,该题要求通过动态规划的方法找到将雕塑按特定条件分组后的最小最终美观值,并给出了具体的实现代码。

4069:[apio2015]巴厘岛的雕塑

Time limit: 1000 ms

Memory limit: 65536 KB

Description

The province of Bali has many sculptures located on its roads. Let’s focus on one of its main roads.

There are N sculptures on that main road, conveniently numbered 1 through N consecutively. The age of sculpture i is Yi years. To make the road more beautiful, the government wants to partition the sculptures into several groups. Then, the government will plant beautiful trees between the groups, to attract more tourists to Bali.

Here is the rule in partitioning the sculptures:

The sculptures must be partitioned into exactly X groups, where A ≤ X ≤ B. Each group must consist of at least one sculpture. Each sculpture must belong to exactly one group. The sculptures in each group must be consecutive sculptures on the road.
For each group, compute the sum of the ages of the sculptures in that group.
Finally, compute the bitwise OR of the above sums. Let’s call this the final beauty value of the partition.
What is the minimum final beauty value that the government can achieve?

Note: the bitwise OR of two non-negative integers P and Q is computed as follows:

Convert P and Q into binary.
Let nP = number of bits of P, and nQ = number of bits of Q. Let M = max(nP, nQ).
Represent P in binary as pM-1pM-2 .. p1p0 and Q in binary as qM-1qM-2 .. q1q0, where pi and qi are the i-th bits of p and q, respectively. The (M-1)st bits are the most significant bits, while the 0th bits are the least significant bits.
P OR Q, in binary, is defined as (pM-1 OR qM-1)(pM-2 OR qM-2)..(p1 OR q1)(p0 OR q0), where
0 OR 0 = 0
0 OR 1 = 1
1 OR 0 = 1
1 OR 1 = 1
Input Format

The first line contains three space-separated integers N, A, and B. The second line contains N space-separated integers Y1, Y2, …, YN.

Output Format

A single line containing the minimum final beauty value.

Sample Input

6 1 3
8 1 2 1 5 4
Sample Output

11
Explanation

Partition the sculptures into 2 groups: (8 1 2) and (1 5 4). The sums are (11) and (10). The final beauty value is (11 OR 10) = 11.

Subtasks

Subtask 1 (9 points)

1 ≤ N ≤ 20
1 ≤ A ≤ B ≤ N
0 ≤ Yi ≤ 1,000,000,000
Subtask 2 (16 points)

1 ≤ N ≤ 50
1 ≤ A ≤ B ≤ min(20, N)
0 ≤ Yi ≤ 10
Subtask 3 (21 points)

1 ≤ N ≤ 100
A = 1
1 ≤ B ≤ N
0 ≤ Yi ≤ 20
Subtask 4 (25 points)

1 ≤ N ≤ 100
1 ≤ A ≤ B ≤ N
0 ≤ Yi ≤ 1,000,000,000
Subtask 5 (29 points)

1 ≤ N ≤ 2,000
A = 1
1 ≤ B ≤ N
0 ≤ Yi ≤ 1,000,000,000

贪心+dp。

从最高位开始枚举,能是1就是1,如何判断当前这一位(第 k 位)能否是1呢?

用dp来做!

f[i][j] 表示前 i 个数分成 j 位满足之前 k1 位的答案(答案中是0的位任何一段不能是1)且第 k 位是1。

dp完后判断一下 f[n][j],j[A,B] 中有没有为 true 的即可。

但是这样做复杂度是 O(logMn3) ,过不了subtask5。

注意到这组数据中 A=1 ,是没有下限的,只要把dp函数变成 g[i] 表示前 i 个数符合条件至少要分几组,判断 g[n] 是否 B 即可。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#define LL long long
#define inf 0x3f3f3f3f
using namespace std;
LL a[2005];
int n,A,B,f[105][105],g[2005];
int ok(LL x,LL y)
{
    return (x|y)==y;
}
int Log(LL x)
{
    int ans=0;
    LL b=1;
    while (b<x)
    {
        b<<=1LL;
        ans++;
    }
    return ans;
}
void Clear()
{
    for (int i=1;i<=n;i++)
        for (int j=1;j<=i;j++)
            f[i][j]=0;
}
void Work1()
{
    LL ans=0;
    for (int now=Log(a[n]);now;now--)
    {
        for (int i=1;i<=n;i++)
            g[i]=inf;
        g[0]=0;
        for (int i=1;i<=n;i++)
            for (int j=0;j<i;j++)
            {
                LL x=a[i]-a[j];
                if (x&(1LL<<(now-1))) continue;
                if (ok(x>>now,ans))
                    g[i]=min(g[i],g[j]+1);
            }
        ans<<=1LL;
        if (g[n]>B) ans|=1;
    }
    cout<<ans<<endl;
}
void Work2()
{
    LL ans=0;
    int tot=Log(a[n]);
    for (int now=tot;now;now--)
    {
        Clear();
        f[0][0]=1;
        for (int i=1;i<=n;i++)
            for (int j=1;j<=i;j++)
                for (int k=0;k<i;k++)
                    if (f[k][j-1])
                    {
                        LL x=a[i]-a[k];
                        if (x&(1LL<<(now-1))) continue;
                        if (ok(x>>now,ans))
                            f[i][j]=1;
                    }
        int t=0;
        for (int i=A;i<=B;i++)
            t|=f[n][i];
        ans<<=1LL;
        if (!t) ans|=1;
    }
    cout<<ans<<endl;
}
int main()
{
    //freopen("t.in","r",stdin);freopen("t.out","w",stdout);
    scanf("%d%d%d",&n,&A,&B);
    for (int i=1;i<=n;i++)
        scanf("%I64d",&a[i]),a[i]=a[i]+a[i-1];
    if (A==1) Work1();
    else Work2();
    return 0;
}

这里写图片描述

这是一道对dp灵活应用的好题啊。

对于前四个subtask的dp方程其实是递推,无法直接判断前 n 位是否可行,我们就从第1位开始判断,因为满足后面的前提是要满足前面的。

第五个subtask没有了下限 A ,变成了最优性问题,就可以dp来做了。

### 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]。 ---
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值