嫌弃短视频浪费时间的用户终于有救了！
YouTube 已经上线新功能，允许用户在设置 > 时间管理中，将 Shorts 的每日上限设置为 0 分钟，即：允许用户彻底关闭 Shorts。@Appinn

如何关闭 Shorts

需要在手机端的 Youtube 上，才可以设置。

具体为：

设置 > 时间管理 > 每日上限 > Shorts 动态浏览时间限制，设置为 0 分钟就好了。

此前的这项功能，最低时间限制为 15 分钟，现在可以设置为 0，就是彻底关闭了。

这一轮给 Youtube 点赞。

原文：https://www.appinn.com/youtube-allows-users-to-disable-shorts/

短视频，真的是太浪费时间了。有一个限制，还是很棒的。

另外，关于 YouTube还有一则消息，YouTube 在 2025 年超越迪士尼的媒体业务，成为全球最大的媒体公司。

（YouTube 在 2025 年的收入预计将达到 620 亿美元，而华特迪士尼公司的媒体业务年收入为 609 亿美元（不包括迪士尼利润丰厚的体验部门）。

相关阅读

• 国产软件正当红，126 款国货之光限时大促：Eagle、Xmind、白描 PDF 等
• 时隔11天，OpenClaw 2026.3.23 发布，内置 ClawHub 插件/技能市场
• AI图片放大还保真？Aiarty Image Enhancer 实测+保姆级教程
• 微软向“预览体验成员”发送中文邮件：我们对 Windows 质量的承诺
• 受够了老旧的终端工具？试试 iShellPro 3.0，运维人的新选择

我最近开始认真对待图片上的水印，是因为一件有点特别的事情。

为什么要去水印

说起来，就在前不久。去参加亲人的葬礼（不要害怕，喜丧），当时请的人一条龙服务，也包括遗像。

是的，你想到了吧，遗像的右下角就明晃晃的写着「豆包AI生成」几个大字。

真的很大，因为照片是放大打印出来的，比豆包原版的水印字体还要大。

当时这个情形，也没有人说什么，但…感觉起来还是有点怪。

先不说这个一条龙服务好不好的问题，他们省去了找人制作照片这个步骤，但实在是太粗暴了。

要知道那张照片是会被抱着走很长一段路的。

有一种赛博世界、现实世界和灵界，三界融合的感觉…

也是从那一刻开始，我突然觉得，有些水印，真的不该存在。

豆包去水印

青小蛙找到了一款只有 31.17KiB 大小的 Chrome 扩展，名字就叫豆包去水印，它能在用户点击下载时，自动下载无水印图片，简单快捷。

使用方法

在网页版豆包生成了图片之后，不要右键下载。

• 第一步：点击图片放大
• 第二步：点击下载原图

下载回来的就是无水印图片。

在扩展页面，还能设置下载的文件名前缀，以及历史记录：

这个历史记录很全，带有两条 URL：带水印和不带水印的。

获取

• Chrome 商店

原文：https://www.appinn.com/doubao-image-qushuiyin/

相关阅读

• 微软的 150 款免费软件[部分，待更新]
• eZy Watermark lite – 在 iPhone、iPad 上为照片添加水印
• AHK Screen WaterMark – 屏幕水印小众版[.net]
• 七牛云赠送 1000 万 Token，可使用 DeepSeek、GLM、Minimax、Qwen 等主流模型
• 如何去除 Windows 10 / 11 预览版桌面右下角的水印

本周赛博领鸡蛋略敷衍，Epic 把上周厂商限免的游戏《女神救地球：重生》算进了自己的限免，实际上上周的限免截止日期就是4.16。所以，本周只有一款 PC 新游戏《Prop Sumo》和一款手机游戏《Dumb Ways to Draw》。

可以直接通过网页领取，无需安装客户端，无需真的玩。

《Prop Sumo》

一款轻松有趣的物理对抗类派对游戏，玩家需要操控角色在各种奇特场景中进行推挤对战，把对手挤出场地即可获胜。整体玩法简单粗暴，但非常适合朋友一起开黑。

轻量级多人欢乐游戏，类似物理版“大乱斗”，不求深度但很容易上头，属于白拿不亏类型。

新上架游戏，暂无更多评价。

限免地址：https://store.epicgames.com/zh-CN/p/propsumo-ca8bd7

《女神救地球：重生》

上周免过了。

一款风格非常奇特的养成类模拟游戏，你需要照顾一位被困在花盆里的“爱之女神”，帮助她恢复力量，从而拯救世界。

设定非常抽象，但也正是它的魅力所在，有点 cult 味道的小众作品，适合喜欢奇怪游戏的人收藏。

限免地址：https://store.epicgames.com/zh-CN/p/tomak-save-the-earth-regeneration-c1207c

《蠢蠢的死法画画》

延续“Dumb Ways”系列风格的创意绘画解谜游戏，玩家需要通过画线来保护角色或解决问题，玩法简单但脑洞很大。

轻松休闲的小品游戏，适合碎片时间玩一玩，典型“顺手领一个”的类型。

另外，蠢蠢的死法系列，这算是全部都限免过了吧。

限免地址：

• 安卓
• 苹果

原文：https://www.appinn.com/eggs-26410/

相关阅读

• 本周赛博领鸡蛋[4.3~4.9]
• 本周赛博领鸡蛋[2.27~3.6]
• 本周赛博领鸡蛋[3.13~3.19]
• 本周赛博领鸡蛋[3.20~3.26]
• 本周赛博领鸡蛋[3.27~4.3]

写作的地方换了。
以后新的文章都发到这里： https://jefftay.com
发在 WordPress 的旧文章大多已经迁移了过去。
有空来坐坐。

  Chouet et al., 2010, JGR

A. A Simple Sequence

大致题意

要求你生成一个排列，满足

$a_1 \space mod \space a_2 \geq a_2 \space mod \space a_3 \dots a_{n-2} \space mod \space a_{n-1} \geq a_{n-1} \space mod \space a_n$

思路

由于这里可以是 $\geq$，而 $n \space n-1 = 1$，是一个显然的等式，所以直接倒序输出即可

AC code

1
2
3
4
5
6
7
8
9

void solve() {
    int _;
    cin >> _;
    for (int ts = 1; ts <= _; ++ts) {
        int n;
        cin >> n;
        for (int i = n; i >= 1; --i) cout << i << " \n"[i == 1];
    }
}

B. Simply Sitting on Chairs

大致题意

有一个 $n$ 的排列 $p$，然后需要完成如下操作：

从第一个值开始往后逐个选择，如果选择了这个值 $i$，那么接下来就不能选择 $p_i$

问最多可以选多少个值

思路

其实也非常简单，只要选择的 $i \geq p_i$ 就行了

AC code

1
2
3
4
5
6
7
8
9
10
11
12
13
14

void solve() {
    int _;
    cin >> _;
    for (int ts = 1; ts <= _; ++ts) {
        int n, ans = 0;
        cin >> n;
        for (int i = 0; i < n; ++i) {
            int x;
            cin >> x;
            ans += x <= i + 1;
        }
        cout << ans << endl;
    }
}

C2. A Simple GCD Problem

大致题意

有两个数组 $a, b$，都是长度 $n$，现在希望生成一个新的数组 $a’$，满足

$a’_i \in \Set{a_i, [1, b_i]}, \forall \Set{l, r} (1 \leq l < r \leq n), gcd(a_l, a_{l+1}, a_{l+2}, \dots, a_{r}) = gcd(a’_l, a’_{l+1}, a’_{l+2}, \dots, a’_{r})$

问最多可以同时存在多少个 $a’_i$ 满足 $a’_i \neq a_i$

思路

首先先分析题目中提到的 $gcd(a_l, a_{l+1}, a_{l+2}, \dots, a_{r}) = gcd(a’_l, a’_{l+1}, a’_{l+2}, \dots, a’_{r})$

看起来很吓人，实际上根据 $gcd$ 的性质，可以得到 $gcd(gcd(a, b), gcd(b, c)) = gcd(a, b, c)$

而题目中提到的是$\forall \Set{l, r} (1 \leq l < r \leq n)$，由于任意区间的 $gcd$ 等于这个区间里的相邻值的 $gcd$ 再做 $gcd$

所以要求条件可以转为: $\forall i (1 \leq i < n), gcd(a_i, a_{i+1}) = gcd(a’_i, a’_{i+1})$

要满足这条，我们需要先找出一个数组 $c$，满足 $c_i = gcd(a_i, a_{i+1})$，这不是什么难事

显然我们可以得到，最终的 $a’$ 满足: $gcd(a’_i, a’_{i-1}) = c_{i-1}, gcd(a’_i, a’_{i+1}) = c_{i+1}$

根据 $gcd$ 的性质，我们可以得到 $a’_i = x \times lcm(c_{i-1}, c_i), x \geq 1$

由此我们可以得到 $a’$ 数组的每一项的最小可选值，即 $a’_i = lcm(c_{i-1}, c_i)$

至此，我们已经完成了 Easy Version 的题解。由于 $b_i = a_i$，所以如果 $lcm(c_{i-1}, c_i) = a_i$，那么就不可能存在 $a’_{i} \neq a_{i}$

接下来是讨论 Hard 部分的解决方案

显然，如果 $lcm(c_{i-1}, c_i) \neq a_i$ 的话，我们就可以选择令 $a’_{i} = lcm(c_{i-1}, c_i)$，因为再乘上任何值都有可能让 $gcd$ 发生变化（变大）

接下来核心是要处理这些不满足的值，也就是 $lcm(c_{i-1}, c_i) = a_i$ 的值，尝试找到一个 $x$ 使得 $x \times lcm(c_{i-1}, c_i) \neq a_i$ 且不改变 $gcd$ 关系

由于不能改变 $gcd$ 关系，假定 $a’_i = x_i \times lcm(c_{i-1}, c_i)$，那么 $gcd(x_i, a’_{i-1}) = gcd(x_i, a’_{i+1}) = 1$

扩展后可以得到：

$gcd(x_i, x_{i-1}) = gcd(x_i, x_{i+1}) = gcd(x_i, lcm(c_{i-2}, c_{i-1})) = gcd(x_i, lcm(c_{i}, c_{i+1}))$

即有很多很多的互质

显然我们很容易想到用素数，因为任意两个素数之间肯定互质，由于本身是乘法，且只需要找到相互互质的值即可，所以只需要限制在较小的值内即可

我用了 100 以内的素数，通过 dp 的方式，枚举每一位乘上每一种素数的情况

我的 dp 算法里，下标 $x$ 表示第几个素数，其中 $0$ 表示 $lcm(c_{i-1}, c_i)$ 本体，而 $max(x)$ 表示 $a_i$ 本身

AC code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

#define int long long
 
int gcd(const int a, const int b) {
    if (b == 0) return a;
    return gcd(b, a % b);
}
 
void solve() {
    vector<int> primes;
    primes.push_back(1);
    vector isPrime(100, true);
    for (int i = 2; i < 100; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
        }
        for (int j = i * i; j < 100 && j > 0; j += i) {
            isPrime[j] = false;
        }
    }

    int _;
    cin >> _;
    for (int ts = 1; ts <= _; ++ts) {
        int n;
        cin >> n;
        vector<int> a(n), b(n), c(n);
        for (int i = 0; i < n; i++) cin >> a[i];
        for (int i = 0; i < n; i++) cin >> b[i];
 
        for (int i = 0; i < n; i++) {
            if (i == 0) {
                c[i] = gcd(a[0], a[1]);
            } else if (i == n - 1) {
                c[i] = gcd(a[i - 1], a[i]);
            } else {
                const int x = gcd(a[i - 1], a[i]);
                const int y = gcd(a[i] , a[i + 1]);
                c[i] = x * y / gcd(x, y);
            }
        }
        vector<int> dp[2];
        dp[0].resize(primes.size() + 1);
        dp[1].resize(primes.size() + 1);
        int cur = 0, nxt = 1, ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < primes.size() + 1; ++j) {
                const int v = j == primes.size() ? a[i] : c[i] * primes[j];
                dp[nxt][j] = -1;
                if (v > b[i] && v != a[i]) continue;
                if (i == 0) {
                    dp[nxt][j] = v != a[i];
                    continue;
                }
 
                for (int k = 0; k < primes.size() + 1; ++k) {
                    const int u = k == primes.size() ? a[i - 1] : c[i - 1] * primes[k];
                    if (gcd(u, v) == gcd(c[i - 1], c[i])) {
                        dp[nxt][j] = max(dp[nxt][j], dp[cur][k] + (v != a[i]));
                    }
                }
            }
            swap(cur, nxt);
        }
        for (auto x : dp[cur]) ans = max(ans, x);
        cout << ans << endl;
    }
}