登录
Vanir：一款基于基于源代码的静态分析工具
2025年1月14日 22:47
关于Vanir
Vanir是是一款基于源代码的静态分析工具，可自动识别目标系统中缺失的安全补丁列表。默认情况下，Vanir 会从开源漏洞 (OSV) 中提取最新的 CVE 及其相应的签名，以便用户可以透明地扫描缺失的补丁以获取最新的 CVE 列表。
普通视图
今天 — 2025年1月18日技术
简单了解vue3双端diff算法，以及为什么使用v-for时必须要给每个元素添加key
2025年1月18日 11:27
众所周知，vue内部使用的是虚拟节点。当组件状态更改时，vue内部会对比老节点和新节点的差异（对比的是虚拟节点），最后根据差异再来操作真实dom节点...........
不花一分钱，快速打造专属个性化个人主页
2025年1月18日 11:26
引言 个人博客的价值与重要性 在当今数字化信息爆炸的时代，个人博客不仅是一个表达自我、分享知识和见解的平台，更是建立个人品牌、提升在线影响力的重要工具。对于技术专家、内容创作者以及任何希望在网络空间中
什么是双键缓存？我们必须了解的浏览器缓存新规则！
2025年1月18日 11:11
昨天有位同学问我：“Sunday 老师，为什么我的静态资源明明缓存了，但换个站点访问，又得重新下载？” 这个本质上就是因为 双键缓存（Double-keyed Caching）导致的......
Mousetrap：打造高效键盘快捷键体验的JavaScript库
2025年1月18日 10:17
Mousetrap是轻量级JavaScript库，提供丰富的快捷键绑定功能，支持多种主流浏览器和移动端，简化跨平台快捷键绑定，支持单个按键、组合按键、按键序列绑定，阻止默认行为，是实现键盘快捷键功能的
Outlaw挖矿僵尸网络近期活动分析
2025年1月14日 18:00
1 概述
近期，安天CERT监测到多起Outlaw挖矿僵尸网络攻击事件，该挖矿僵尸网络最早于2018年被发现，主要针对云服务器从事挖矿活动，持续活跃。安天CERT在分析近期的攻击事件中发现，该挖矿僵尸网络样本在第三版本基础上有了重要更新，其功能更加多样、隐匿性更高、清除更加困难。主要传播途径和功能依旧是SSH暴力破解攻击目标系统，植入SS
如何优雅地处理第三方网站高清 Logo 显示？
2025年1月18日 10:46
学习如何优雅地处理第三方网站高清Logo显示问题。本文详细介绍了一个健壮的React组件实现方案，包括多重备选图标源、加载状态占位符、超时处理机制和优雅的降级显示。
JavaScript 数组方法大盘点：从新手到大佬，快速掌握所有必备技能！🎉
2025年1月17日 21:37
本文介绍了 JavaScript 数组常用方法，如 `push`、`pop`、`map` 等，帮助开发者高效操作数组，提升开发效率。
eslint配置文件的名字是eslintrc.cjs,但是有的名字是eslint.config.js
2025年1月17日 21:10
以下是关于 ESLint 配置文件名称不同的解释： 1. 传统的 ESLint 配置文件：.eslintrc.cjs 1.1 历史背景 早期版本： 早期的 ESLint 配置文件通常使用 .eslin
在electron中实现一个桌面悬浮球
2025年1月17日 20:47
在electron + vue3 搭建的应用中实现了一个桌面悬浮球/mini窗口的功能，支持任意拖拽、丝滑的菜单折叠展开动画效果。
Node.js系列：事件驱动的核心机制事件循环
2025年1月17日 19:30
❤️ 事件循环：处理异步操作的机制 目的：使Nodejs能够在单线程环境下高效运行 一、事件循环运行机制：依赖libuv库 libuv为Nodejs提供了高效的事件驱动的I/O操作能力,libuv负责
【虚拟列表·终章】不定高度+动态图片加载，十万条数据流畅渲染全攻略！
2025年1月17日 18:37
大家好，我是 前端大卫。 在线 Demo 地址: https://codesandbox.io/p/devbox/advance-g7j3xc 今天是【虚拟列表】系列的终章，我将带大家深入探讨不定高
前端性能优化中的技能CD和回城
2025年1月17日 18:27
这篇文章深入探讨了前端性能优化中的防抖与节流技巧。防抖通过延迟执行来避免频繁触发事件，适用于搜索建议、表单验证等场景；而节流则控制执行频率，适用于滚动加载、数据统计等场景。
FreeBuf周报 | Azure AI被黑客越狱；Windows远程桌面网关出现重大漏洞
2025年1月17日 13:49
各位 Buffer 周末好，以下是本周「FreeBuf周报」，我们总结推荐了本周的热点资讯、安全事件、一周好文和省心工具，保证大家不错过本周的每一个重点！
求出数组中最大序列值
2025年1月3日 09:21
方法一：动态规划
思路
长度为 $2k$ 的序列的值的计算方式为，先将其拆成长度相同的前后子串，然后分别计算各子串的所有元素的按位或的结果，再将两个按位或的结果进行按位异或。为了求出 $\textit{nums}$ 的长度为 $2k$ 的子序列的最大值，可以将 $\textit{nums}$ 分成左右两半，分别求出每一半中，长度为 $k$ 的子序列的按位或的所有可能性，再两两求异或的最大值。这样的分法一共有 $n-2k+1$ 种，其中 $n$ 为数组 $\textit{nums}$ 的长度。并且我们可以用动态规划的方法来求出长度为 $k$ 的子序列的按位或的结果的所有可能性。
记 $\textit{dp}[i][j]$ 为哈希集合，表示 $\textit{nums}[0...i]$ 中长度为 $j$ 的自序列按位或的所有可能性。$j \leq k$，且当 $j$ 为 $0$ 时，$\textit{dp}[i][j]$ 为空集。又根据题目限制，$\textit{nums}$ 元素的值为 $0$ 到 $127$，因此 $\textit{dp}[i][j]$ 最多包含 $128$ 个元素。进行转移时，$\textit{dp}[i][j]$ 首先会包含 $\textit{dp}[i-1][j]$ 的所有元素，表示不选取 $\textit{nums}[i]$。还可以将 $\textit{dp}[i-1][j-1]$ 中的所有元素与 $\textit{nums}[i]$ 进行按位或，将结果添加进 $\textit{dp}[i][j]$，表示选取$\textit{nums}[i]$。我们可以将上述步骤抽象成一个函数，并进一步降低空间复杂度，只返回值 $j=k$ 时的 $dp$值，可以算出左一半的长度为 $k$ 的子序列的按位或的所有可能性。再将 $\textit{nums}$ 进行逆序后再次应用这个函数，即可计算出右一半的的长度为 $k$ 的子序列的按位或的所有可能性。再两两求异或的最大值返回。
我们可以将
代码
###Python
class Solution:
def maxValue(self, nums: List[int], k: int) -> int:
def findORs(nums: List[int], k: int) -> List[set[int]]:
dp = []
prev = [set() for _ in range(k + 1)]
prev[0].add(0)
for i, num in enumerate(nums):
for j in range(min(k - 1, i + 1), -1, -1):
for x in prev[j]:
prev[j + 1].add(x | num)
dp.append(prev[k].copy())
return dp
A = findORs(nums, k)
B = findORs(nums[::-1], k)
mx = 0
for i in range(k - 1, len(nums) - k):
mx = max(mx, *(a ^ b for a in A[i] for b in B[-i - 2]))
return mx
###Java
class Solution {
public int maxValue(int[] nums, int k) {
List<Set<Integer>> A = findORs(nums, k);
List<Set<Integer>> B = findORs(reverse(nums), k);
int mx = 0;
for (int i = k - 1; i < nums.length - k; i++) {
for (int a : A.get(i)) {
for (int b : B.get(nums.length - i - 2)) {
mx = Math.max(mx, a ^ b);
}
}
}
return mx;
}
private List<Set<Integer>> findORs(int[] nums, int k) {
List<Set<Integer>> dp = new ArrayList<>();
List<Set<Integer>> prev = new ArrayList<>();
for (int i = 0; i <= k; i++) {
prev.add(new HashSet<>());
}
prev.get(0).add(0);
for (int i = 0; i < nums.length; i++) {
for (int j = Math.min(k - 1, i + 1); j >= 0; j--) {
for (int x : prev.get(j)) {
prev.get(j + 1).add(x | nums[i]);
}
}
dp.add(new HashSet<>(prev.get(k)));
}
return dp;
}
private int[] reverse(int[] nums) {
int[] reversed = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
reversed[i] = nums[nums.length - 1 - i];
}
return reversed;
}
}
###C#
public class Solution {
public int MaxValue(int[] nums, int k) {
var A = FindORs(nums, k);
Array.Reverse(nums);
var B = FindORs(nums, k);
int mx = 0;
for (int i = k - 1; i < nums.Length - k; i++) {
foreach (int a in A[i]) {
foreach (int b in B[nums.Length - i - 2]) {
mx = Math.Max(mx, a ^ b);
}
}
}
return mx;
}
public List<HashSet<int>> FindORs(int[] nums, int k) {
var dp = new List<HashSet<int>>();
var prev = new List<HashSet<int>>();
for (int i = 0; i <= k; i++) {
prev.Add(new HashSet<int>());
}
prev[0].Add(0);
for (int i = 0; i < nums.Length; i++) {
for (int j = Math.Min(k - 1, i + 1); j >= 0; j--) {
foreach (int x in prev[j]) {
prev[j + 1].Add(x | nums[i]);
}
}
dp.Add(new HashSet<int>(prev[k]));
}
return dp;
}
}
###C++
class Solution {
public:
int maxValue(vector<int>& nums, int k) {
auto findORs = [&](const vector<int>& nums, int k) -> vector<unordered_set<int>> {
vector<unordered_set<int>> dp;
vector<unordered_set<int>> prev(k + 1);
prev[0].insert(0);
for (int i = 0; i < nums.size(); ++i) {
for (int j = min(k - 1, i + 1); j >= 0; --j) {
for (int x : prev[j]) {
prev[j + 1].insert(x | nums[i]);
}
}
dp.push_back(prev[k]);
}
return dp;
};
vector<unordered_set<int>> A = findORs(nums, k);
vector<unordered_set<int>> B = findORs(vector<int>(nums.rbegin(), nums.rend()), k);
int mx = 0;
for (size_t i = k - 1; i < nums.size() - k; ++i) {
for (int a : A[i]) {
for (int b : B[nums.size() - i - 2]) {
mx = max(mx, a ^ b);
}
}
}
return mx;
}
};
###Go
func maxValue(nums []int, k int) int {
findORs := func(nums []int, k int) []map[int]bool {
dp := make([]map[int]bool, 0)
prev := make([]map[int]bool, k + 1)
for i := 0; i <= k; i++ {
prev[i] = make(map[int]bool)
}
prev[0][0] = true
for i := 0; i < len(nums); i++ {
for j := min(k - 1, i + 1); j >= 0; j-- {
for x := range prev[j] {
prev[j + 1][x | nums[i]] = true
}
}
current := make(map[int]bool)
for key := range prev[k] {
current[key] = true
}
dp = append(dp, current)
}
return dp
}
A := findORs(nums, k)
reverse(nums)
B := findORs(nums, k)
mx := 0
for i := k - 1; i < len(nums) - k; i++ {
for a := range A[i] {
for b := range B[len(nums) - i - 2] {
if a ^ b > mx {
mx = a ^ b
}
}
}
}
return mx
}
func reverse(nums []int) {
for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
nums[i], nums[j] = nums[j], nums[i]
}
}
###C
typedef struct {
int key;
UT_hash_handle hh;
} HashItem;
HashItem *hashFindItem(HashItem **obj, int key) {
HashItem *pEntry = NULL;
HASH_FIND_INT(*obj, &key, pEntry);
return pEntry;
}
bool hashAddItem(HashItem **obj, int key) {
if (hashFindItem(obj, key)) {
return false;
}
HashItem *pEntry = (HashItem *)malloc(sizeof(HashItem));
pEntry->key = key;
HASH_ADD_INT(*obj, key, pEntry);
return true;
}
void hashFree(HashItem **obj) {
HashItem *curr = NULL, *tmp = NULL;
HASH_ITER(hh, *obj, curr, tmp) {
HASH_DEL(*obj, curr);
free(curr);
}
}
void findORs(int* nums, int numsSize, int k, HashItem** dp) {
HashItem *prev[k + 1];
for (int i = 0; i <= k; i++) {
prev[i] = NULL;
}
hashAddItem(&prev[0], 0);
for (int i = 0; i < numsSize; ++i) {
for (int j = fmin(k - 1, i + 1); j >= 0; --j) {
for (HashItem *pEntry = prev[j]; pEntry; pEntry = pEntry->hh.next) {
int x = pEntry->key;
hashAddItem(&prev[j + 1], x | nums[i]);
}
}
for (HashItem *pEntry = prev[k]; pEntry; pEntry = pEntry->hh.next) {
int x = pEntry->key;
hashAddItem(&dp[i], x);
}
}
for (int i = 0; i <= k; i++) {
hashFree(&prev[i]);
}
};
void reverse(int *nums, int numsSize) {
for (int i = 0, j = numsSize - 1; i < j; i++, j--) {
int x = nums[i];
nums[i] = nums[j];
nums[j] = x;
}
}
int maxValue(int* nums, int numsSize, int k) {
HashItem *A[numsSize];
HashItem *B[numsSize];
for (int i = 0; i < numsSize; i++) {
A[i] = B[i] = NULL;
}
findORs(nums, numsSize, k, A);
reverse(nums, numsSize);
findORs(nums, numsSize, k, B);
int mx = 0;
for (size_t i = k - 1; i < numsSize - k; ++i) {
for (HashItem *pEntry = A[i]; pEntry; pEntry = pEntry->hh.next) {
int a = pEntry->key;
for (HashItem *pEntry = B[numsSize - i - 2]; pEntry; pEntry = pEntry->hh.next) {
int b = pEntry->key;
mx = fmax(mx, a ^ b);
}
}
}
for (int i = 0; i < numsSize; i++) {
hashFree(&A[i]);
hashFree(&B[i]);
}
return mx;
}
###JavaScript
var maxValue = function(nums, k) {
function findORs(nums, k) {
const dp = [];
const prev = Array.from({ length: k + 1 }, () => new Set());
prev[0].add(0);
for (let i = 0; i < nums.length; i++) {
for (let j = Math.min(k - 1, i + 1); j >= 0; j--) {
for (const x of prev[j]) {
prev[j + 1].add(x | nums[i]);
}
}
dp.push(new Set(prev[k]));
}
return dp;
}
const A = findORs(nums, k);
nums.reverse();
const B = findORs(nums, k);
let mx = 0;
for (let i = k - 1; i < nums.length - k; i++) {
for (const a of A[i]) {
for (const b of B[nums.length - i - 2]) {
mx = Math.max(mx, a ^ b);
}
}
}
return mx;
};
###TypeScript
function maxValue(nums: number[], k: number): number {
function findORs(nums: number[], k: number): Set<number>[] {
const dp: Set<number>[] = [];
const prev: Set<number>[] = Array.from({ length: k + 1 }, () => new Set());
prev[0].add(0);
for (let i = 0; i < nums.length; i++) {
for (let j = Math.min(k - 1, i + 1); j >= 0; j--) {
for (const x of prev[j]) {
prev[j + 1].add(x | nums[i]);
}
}
dp.push(new Set(prev[k]));
}
return dp;
}
const A = findORs(nums, k);
nums.reverse();
const B = findORs(nums, k);
let mx = 0;
for (let i = k - 1; i < nums.length - k; i++) {
for (const a of A[i]) {
for (const b of B[nums.length - i - 2]) {
mx = Math.max(mx, a ^ b);
}
}
}
return mx;
};
###Rust
use std::collections::HashSet;
use std::cmp::{max, min};
impl Solution {
pub fn max_value(nums: Vec<i32>, k: i32) -> i32 {
fn find_ors(nums: &Vec<i32>, k: i32) -> Vec<HashSet<i32>> {
let mut dp = Vec::new();
let mut prev = vec![HashSet::new(); k as usize + 1];
prev[0].insert(0);
for i in 0..nums.len() {
for j in (0..= min(k as usize - 1, i + 1)).rev() {
let (before, after) = prev.split_at_mut(j + 1);
for &x in &before[j] {
after[0].insert(x | nums[i]);
}
}
dp.push(prev[k as usize].clone());
}
dp
}
let a = find_ors(&nums, k);
let reversed_nums: Vec<i32> = nums.iter().rev().cloned().collect();
let b = find_ors(&reversed_nums, k);
let mut mx = 0;
for i in k as usize - 1..nums.len() - k as usize {
for &a_val in &a[i] {
for &b_val in &b[nums.len() - i - 2] {
mx = mx.max(a_val ^ b_val);
}
}
}
mx
}
}
复杂度分析
-
时间复杂度：$O(n \times k \times U + n \times U^2)$，其中 $n$ 是数组 $\textit{nums}$ 的长度，$U$ 是数组元素的可能性集合大小。$\textit{dp}$ 的状态有 $O(n\times k)$ 种，每个状态消耗 $O(U)$ 计算。最后两两求异或消耗 $O(n\times U^2)$ 的时间。
-
空间复杂度：$O(n \times U)$。
HarmonyOSNext 端云一体化（4）
2025年1月18日 00:54
HarmonyOSNext 端云一体化（4） 在上一章节我们讲了数据库数据表的一些基本操作。如query、upsert、delete和calculateQuery。这一章节主要来讲解各种查询条件操作。
每日一题-求出数组中最大序列值🔴
2025年1月18日 00:00
给你一个整数数组 nums 和一个 正 整数 k 。
定义长度为 2 * x 的序列 seq 的 值 为：
-
(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1]).
请你求出 nums 中所有长度为 2 * k 的 子序列 的 最大值 。
示例 1：
输入：nums = [2,6,7], k = 1
输出：5
解释：
子序列 [2, 7] 的值最大，为 2 XOR 7 = 5 。
示例 2：
输入：nums = [4,2,5,6,7], k = 2
输出：2
解释：
子序列 [4, 5, 6, 7] 的值最大，为 (4 OR 5) XOR (6 OR 7) = 2 。
提示：
2 <= nums.length <= 4001 <= nums[i] < 271 <= k <= nums.length / 2
jsonp解决前端跨域问题
2025年1月17日 23:45
各位大佬我们今天聊聊前端热门八股-跨域问题 那什么叫从一个域到另一个域呢？ 在 Web 开发中，"域"（或"源"）是指一个特定的协议、域名和端口的组合。浏览器的同源策略限制了从一个源加载的文档或脚本与
