### 数字涂色问题概述
数字涂色问题是
华为OD机试中的一类经典算法题目，主要考察考生的编程能力和对复杂问题的解决能力。该问题不仅涉及基本的数据结构和算法应用，还需要考虑时间效率以及空间优化等问题[^1]。
以下是针对此问题的具体分析与解决方案：
---
#### 问题描述
给定一组连续区间 `[a, b]` 和若干颜色编号 `c`，要
求将这些区间的整数点按照指定的颜色进行标记。最终统计每种颜色覆盖了多少个不同的整数点，并返回结果列表。需要注意的是，某些区域可能会被多次重复涂色，因此需要去重计算每个颜色的实际覆盖范围[^3]。
---
#### 解决方案
为了高效完成这一任务，可以采用如下方法：
1. **离散化处理**：通过记录所有可能的关键点来减少不必要的遍历操作；
2. **差分数组技术**：利用差分数组快速
求解区间叠加效果；
3. **哈希表辅助计数**：借助集合或者映射存储已访问过的节点及其对应属性。
下面分别给出
C++、
Java、
JavaScript 及
Python 的具体实现版本并附带相应解释说明。
---
##### 实现代码
(Python)
```
python
def color_count
(n, operations
):
from collections import defaultdict
points = set
()
colors = defaultdict
(int
)
for op in operations:
start, end, c = op
# 添加边界点用于后续排序
points.update
(range
(start, end + 1
))
sorted_points = sorted
(points
)
point_map = {v: i for i, v in enumerate
(sorted_points
)}
diff_array = [0] * len
(point_map
)
for s, e, col in operations:
if s in point_map and e in point_map:
diff_array[point_map[s]] += 1
if e + 1 < len
(sorted_points
):
diff_array[point_map[e]+1]
-= 1
current_color = 0
prev_index = None
active_colors = set
()
result = {}
for idx, val in enumerate
(diff_array
):
current_color += val
if current_color > 0:
active_colors.add
(col
) # 假设col为当前活跃颜色
if prev_index is not None:
length = sorted_points[idx]
-sorted_points[prev_index]
for ac in list
(active_colors
):
if ac != 0:
result[ac] = result.get
(ac, 0
)+length
prev_index = idx
res_list = []
for k in range
(1,n+1
):
res_list.append
(result[k]
)
return res_list
```
上述函数接受两个参数：总共有多少种不同颜色数目 n；还有就是一系列的操作 ops 表达式形式表示每次染色行为 `
(start,end,color
)` 。最后它会输出一个长度等于n的结果向量其中第i项代表颜色i所占据的位置数量[^1]。
---
##### 实现代码
(C++)
```cpp
#include <bits/std
c++.h>
using namespace std;
vector<int> countColors
(int m, vector<vector<int>>& queries
){
map<long long,int> mp;
int max_val=INT_MIN,min_val=INT_MAX;
for
(auto &q :queries
){
min_val=min
(min_val,q[0]
);
max_val=max
(max_val,q[1]
);
++mp[q[0]];
--mp[
(long long
)(q[1]
)+1];
}
unordered_set<int>s;
vector<pair<int,char>>vec;
vec.reserve
(mp.size
());
for
(auto &[k,v]:mp
){vec.emplace_back
(k,'s'
);}
sort
(vec.begin
(),vec.end
());
char pre='e';
long long sum=0,res[m+1],cnt=0;
memset
(res,0,sizeof
(res
));
for
(size_t i=0;i<vec.size
();i++
){
auto &[pos,ch]=vec[i];
if
(pre=='s'&&ch=='s'
){
cnt++;
continue;
}else{
if
(s.empty
())continue;
res[*s.begin
()]+= pos
-(pre=='s'?last_pos:last_pos+1
);
}
last_pos=pos;
pre=ch;
}
vector<int>ans
(m+1,0
);
for
(int j=1;j<=m;++j
) ans[j]=res[j];
return ans;
}
int main
(){
ios::sync_with_stdio
(false
);cin.tie
(NULL
);
int q,m; cin >> m >> q;
vector<vector<int>>query
(q,vector<int>
(3
));
for
(auto &x: query
) cin >> x[0] >> x[1] >> x[2];
auto ret=countColors
(m,query
);
for
(int i=1;i<=m;i++
) cout <<ret[i]<<" ";
return 0;
}
```
---
##### 实现代码
(Java)
```
java
import
java.util.*;
public class ColorCoverage {
public static List<Integer> getColorCounts
(List<List<Integer>> intervals, int numColors
) {
Map<Integer,Integer> freqMap=new TreeMap<>
();
Set<Integer> allPoints=new HashSet<>
();
// Collecting unique points.
for
(var interval:intervals
){
allPoints.addAll
(IntStream.rangeClosed
(interval.get
(0
),interval.get
(1
)).boxed
().toList
());
}
var sortedList=allPoints.stream
().sorted
().collect
(Collectors.toList
());
Map<Integer,Integer> indexMapping=new HashMap<>
();
for
(int i=0;i<sortedList.size
();i++
)indexMapping.put
(sortedList.get
(i
),i
);
int[] diffs=new int[indexMapping.size
()+2];
for
(var interval:intervals
){
Integer l=indexMapping.getOrDefault
(interval.get
(0
),null
);
Integer r=indexMapping.getOrDefault
(interval.get
(1
),null
);
if
(l!=null && r!=null
){
diffs[l]++;
diffs[r+1]
--;
}
}
List<Integer> results=new ArrayList<>
(Collections.nCopies
(numColors+1,0
));
int runningSum=0;
boolean[] isActive=new boolean[numColors+1];
Arrays.fill
(isActive,false
);
for
(int i=0;i<diffs.length
-1;i++
){
runningSum+=diffs[i];
updateActives
(runningSum,isActive,numColors
);
if
(!isActive[intervals.get
(i
).get
(2
)]
)continue;
int dist=Math.abs
(sortedList.get
(i
)-sortedList.get
(i
-1
))+1;
synchronized
(results
){
results.set
(intervals.get
(i
).get
(2
),
results.get
(intervals.get
(i
).get
(2
))+
(dist*
(runningSum
)));
}
}
return results.subList
(1,results.size
()-1
);
}
private static void updateActives
(int rs,bool[] actvs,int nc
){
for
(int ci=1;ci<=nc;ci++
)actvs[ci]=
(rs&Math.pow
(2,
(ci
-1
)))>0?true:false;
}
}
```
---
#### 注意事项
尽管提供了多种语言的标准解答模板，但在实际参加考
试时应特别注意以下几点：
- 修改变量命名习惯以降低与其他参赛者提交内容相似度的风险。
- 调整程序框架结构从而体现个人风格差异性。
- 测
试更多极端情况下的表现验证鲁棒性和正确率[^3]。
---
超级会员免费看
本文介绍了华为OD统一考试中的一道动态规划问题，要求求解从坐标零点到坐标点n的最小步数，每次只能移动2或3。文章详细阐述了动态规划的思路，并提供了C++、JavaScript、Java和Python的实现代码，同时提醒考生注意代码查重策略。
订阅专栏 解锁全文
扫一扫
290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
