给定一个长度为 n 的整数数组 nums 。

假设 arrk 是数组 nums 顺时针旋转 k 个位置后的数组，我们定义 nums 的 旋转函数  F 为：

• F(k) = 0 * arrk[0] + 1 * arrk[1] + ... + (n - 1) * arrk[n - 1]

返回 F(0), F(1), ..., F(n-1)中的最大值 。

生成的测试用例让答案符合 32 位 整数。

示例 1:

输入: nums = [4,3,2,6]
输出: 26
解释:
F(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 + 3 + 4 + 18 = 25
F(1) = (0 * 6) + (1 * 4) + (2 * 3) + (3 * 2) = 0 + 4 + 6 + 6 = 16
F(2) = (0 * 2) + (1 * 6) + (2 * 4) + (3 * 3) = 0 + 6 + 8 + 9 = 23
F(3) = (0 * 3) + (1 * 2) + (2 * 6) + (3 * 4) = 0 + 2 + 12 + 12 = 26
所以 F(0), F(1), F(2), F(3) 中的最大值是 F(3) = 26 。

示例 2:

输入: nums = [100]
输出: 0

提示:

• n == nums.length
• 1 <= n <= 105
• -100 <= nums[i] <= 100

After installing Ubuntu 26.04, the desktop is ready to use, but a few setup steps make the system easier to work with day to day. Updating packages, checking drivers, installing media codecs, setting up backups, and reviewing privacy settings are good first tasks on a new installation.

This guide explains what to do after installing Ubuntu 26.04. The checklist is aimed at desktop users who want a clean, practical setup without adding unnecessary tools.

If you have not installed the system yet, start with our guide on how to install Ubuntu 26.04 . If you moved from an older release, see how to upgrade to Ubuntu 26.04 .

Quick Reference #

Update Ubuntu #

Start by updating the package index and installing available updates. This pulls in security fixes, bug fixes, and package updates released after the installation image was created.

Open a terminal and run:

sudo apt update
sudo apt upgrade

Enter your password when prompted and confirm the upgrade. If the update installs a new kernel or graphics driver, reboot before continuing:

sudo reboot

You can also update from the desktop by opening Software Updater from the application menu.

Install Available Drivers #

Ubuntu detects most hardware automatically, but some systems need proprietary drivers for graphics cards, Wi-Fi adapters, or other devices. This is common on laptops and systems with NVIDIA graphics.

Open Software & Updates, go to the Additional Drivers tab, and wait while Ubuntu checks available drivers. If Ubuntu recommends a proprietary driver, select it and apply the change. Reboot after installing graphics or Wi-Fi drivers.

If you selected the third-party software option during installation, your system may already have the correct driver installed. It is still worth checking this screen once on a new system.

Install Media Codecs #

Ubuntu does not include every media codec by default. If you want better support for common audio and video files, Microsoft fonts, and some archive formats, install the restricted extras package:

sudo apt install ubuntu-restricted-extras

During installation, you may be asked to accept the Microsoft font license. Use the keyboard to select OK, press Enter, then select Yes and press Enter again.

After the package is installed, try playing the video or audio file again. For most desktop users, this package is enough for everyday media playback.

Enable Flatpak and Flathub #

Ubuntu includes Snap support by default, and many applications are available from the Ubuntu App Center. Flatpak is another popular desktop app format, and Flathub provides current builds of many Linux desktop applications.

Install Flatpak and the GNOME Software plugin:

sudo apt install flatpak gnome-software-plugin-flatpak

Add the Flathub repository:

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Log out and log back in, or reboot, so desktop app integration is fully available:

sudo reboot

After that, you can install Flatpak applications from Flathub or from GNOME Software if the plugin is active.

Install Common Desktop Apps #

A fresh Ubuntu installation includes a browser, file manager, terminal, text editor, and basic utilities. Most users still add a few daily-use applications.

Common choices include:

• A web browser such as Google Chrome , Chromium, Microsoft Edge, or Firefox.
• A media player such as VLC.
• Development tools such as Node.js , Git, Python, Docker, or Visual Studio Code.
• Communication apps such as Slack, Discord, Zoom, or Teams.
• Desktop apps from Flathub when the Ubuntu repositories or Snap packages do not provide the version you want.

Use the Ubuntu App Center for simple desktop installs. Use apt when a package is available in Ubuntu repositories, and use the vendor’s official package only when you need the current upstream version.

Set Up Backups #

Set up backups before you spend too much time customizing the system. Backups are easier to trust when they are configured early and tested before you need them.

Open Settings > System > Backup and choose where to store your backups. An external drive is the simplest option for a single desktop or laptop. If you already use a cloud storage provider or network storage, configure that target instead.

At minimum, back up your home directory, which contains documents, downloads, browser profiles, SSH keys, and most application settings. If you keep important files outside your home directory, include those paths too.

After the first backup finishes, restore one small test file to confirm that the backup is usable.

Review Privacy and Security Settings #

Open Settings > Privacy & Security and review the options that match how you use the computer. On a laptop, pay special attention to location services, screen lock, automatic suspend, and notifications on the lock screen.

Good defaults for most systems are:

• Disable location services unless you use apps that need location access.
• Keep the screen lock enabled.
• Use a short automatic blank-screen delay on laptops.
• Hide notification details on the lock screen if the computer is used in public places.
• Review diagnostics and error reporting options.

If the computer is shared, create separate user accounts instead of sharing one login. Use an administrator account only when needed, and keep daily users separate when possible.

Enable the Firewall #

Ubuntu includes UFW, a simple firewall tool for managing incoming connections. On a typical desktop system, enabling UFW blocks unsolicited inbound traffic while allowing normal outbound connections.

Enable the firewall:

sudo ufw enable

Check the status:

sudo ufw status

Status: active

If you use SSH, file sharing, development servers, or remote desktop tools, allow those services before relying on the firewall rules. For a full command reference, see our UFW firewall guide .

Customize the Desktop #

Ubuntu 26.04 uses the GNOME desktop with Ubuntu’s dock and appearance settings. You can adjust the most common options from Settings > Appearance.

Useful settings to review include:

• Light or dark style.
• Accent color.
• Dock position and auto-hide behavior.
• Desktop icons.
• Default applications.
• Keyboard shortcuts.
• Display scaling for high-resolution screens.

Do not change every option at once. Make a few changes, use the desktop for a day, then adjust anything that still feels awkward.

Install GNOME Tweaks #

GNOME Tweaks exposes settings that are not shown in the default Settings app. It is useful for changing window behavior, fonts, startup applications, and a few interface details.

Install it with:

sudo apt install gnome-tweaks

Open Tweaks from the application menu. If you also use GNOME Shell extensions, install only the extensions you need and remove ones you no longer use. Too many extensions can make desktop upgrades harder to troubleshoot.

Improve Laptop Battery Life #

On laptops, start with the built-in power settings. Open Settings > Power and choose the profile that matches your current use:

• Power Saver for longer battery life.
• Balanced for normal use.
• Performance when you need maximum speed and the laptop is plugged in.

Also review screen brightness, automatic suspend, Bluetooth, and keyboard backlight settings. Small changes here often matter more than installing extra tools.

If you need more control, you can install TLP:

sudo apt install tlp

Start and enable the service:

sudo systemctl enable --now tlp

Use TLP only if you are comfortable troubleshooting power behavior. On many newer laptops, Ubuntu’s built-in power profiles are enough.

Remove Unused Packages #

After installing updates and applications, remove packages that were installed as dependencies but are no longer needed:

sudo apt autoremove

Review the package list before confirming. autoremove is usually safe, but it is still a good habit to read what will be removed.

You can also clear downloaded package files from the local cache:

sudo apt clean

This frees disk space, but it means packages will need to be downloaded again if you reinstall them later.

Check the Ubuntu Version #

After updates and any reboot, confirm that the system is running Ubuntu 26.04:

lsb_release -a

Distributor ID: Ubuntu
Description: Ubuntu 26.04 LTS
Release: 26.04
Codename: resolute

If lsb_release is not installed, you can check /etc/os-release:

cat /etc/os-release

For more options, see how to check your Ubuntu version .

Next Steps #

Once the desktop basics are in place, install the tools you need for your work. Developers may want Docker , Node.js, Git, Python, or Visual Studio Code. Desktop users may want Chrome, VLC, Flatpak apps, printer support, or cloud sync tools.

If you plan to use the machine as a server, create a separate setup plan. Desktop post-install tasks are different from server hardening, SSH access, service configuration, and firewall rules for hosted applications.

Conclusion #

Ubuntu 26.04 works well after a clean installation, but updates, drivers, codecs, backups, firewall settings, and desktop preferences make the system more practical for daily use. Start with the essentials, then add only the applications and customizations you actually need.

前缀和 + 滑动窗口

为了方便，我们将 $nums$ 的长度记为 $n$。

题目要对「旋转数组」做逻辑，容易想到将 $nums$ 进行复制拼接，得到长度为 $2 * n$ 的新数组，在新数组上任意一个长度为 $n$ 的滑动窗口都对应了一个旋转数组。

然后考虑在窗口的滑动过程中，计算结果会如何变化，假设当前我们处理到下标为 $[i, i + n - 1]$ 的滑动窗口，根据题意，当前结果为：

$$
cur = nums[i] * 0 + nums[i + 1] * 1 + ... + nums[i + n - 1] * (n - 1)
$$

当窗口往后移动一位，也就是窗口的右端点来到 $i + n$ 的位置，左端点来到 $i + 1$ 的位置。

我们需要增加「新右端点」的值，即增加 $nums[i + n] * (n - 1)$，同时减去「旧左端点」的值，即减少 $nums[i] * 0$（固定为 $0$），然后更新新旧窗口的公共部分 $[i + 1, i + n - 1]$。

不难发现，随着窗口的逐步右移，每一位公共部分的权值系数都会进行减一。

$$
nums[i + 1] * 1 + nums[i + 2] * 2 + ... + nums[i + n - 1] * (n - 1)
$$

变为

$$
nums[i + 1] * 0 + nums[i + 2] * 1 + ... + nums[i + n - 1] * (n - 2)
$$

因此，公共部分的差值为 $\sum_{idx = i + 1}^{i + n - 1}nums[idx]$，这引导我们可以使用前缀和进行优化。

至此，我们从旧窗口到新窗口的过渡，都是 $O(1)$，整体复杂度为 $O(n)$。

实现上，我们并不需要真正对 $nums$ 进行复制拼接，而只需要在计算前缀和数组 $sum$ 进行简单的下标处理即可。

代码：

###Java

class Solution {
    public int maxRotateFunction(int[] nums) {
        int n = nums.length;
        int[] sum = new int[n * 2 + 10];
        for (int i = 1; i <= 2 * n; i++) sum[i] = sum[i - 1] + nums[(i - 1) % n];
        int ans = 0;
        for (int i = 1; i <= n; i++) ans += nums[i - 1] * (i - 1);
        for (int i = n + 1, cur = ans; i < 2 * n; i++) {
            cur += nums[(i - 1) % n] * (n - 1);
            cur -= sum[i - 1] - sum[i - n];
            if (cur > ans) ans = cur;
        }
        return ans;
    }
}

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

最后

如果有帮助到你，请给题解点个赞和收藏，让更多的人看到 ~ ("▔□▔)/

也欢迎你 关注我 和 加入我们的「组队打卡」小群 ，提供写「证明」&「思路」的高质量题解。

所有题解已经加入 刷题指南，欢迎 star 哦 ~

方法一：迭代

思路

记数组 $\textit{nums}$ 的元素之和为 $\textit{numSum}$。根据公式，可以得到：

• $F(0) = 0 \times \textit{nums}[0] + 1 \times \textit{nums}[1] + \ldots + (n-1) \times \textit{nums}[n-1]$
• $F(1) = 1 \times \textit{nums}[0] + 2 \times \textit{nums}[1] + \ldots + 0 \times \textit{nums}[n-1] = F(0) + \textit{numSum} - n \times \textit{nums}[n-1]$

更一般地，当 $1 \le k \lt n$ 时，$F(k) = F(k-1) + \textit{numSum} - n \times \textit{nums}[n-k]$。我们可以不停迭代计算出不同的 $F(k)$，并求出最大值。

代码

###Python

class Solution:
    def maxRotateFunction(self, nums: List[int]) -> int:
        f, n, numSum = 0, len(nums), sum(nums)
        for i, num in enumerate(nums):
            f += i * num
        res = f
        for i in range(n - 1, 0, -1):
            f = f + numSum - n * nums[i]
            res = max(res, f)
        return res

###Java

class Solution {
    public int maxRotateFunction(int[] nums) {
        int f = 0, n = nums.length, numSum = Arrays.stream(nums).sum();
        for (int i = 0; i < n; i++) {
            f += i * nums[i];
        }
        int res = f;
        for (int i = n - 1; i > 0; i--) {
            f += numSum - n * nums[i];
            res = Math.max(res, f);
        }
        return res;
    }
}

###C#

public class Solution {
    public int MaxRotateFunction(int[] nums) {
        int f = 0, n = nums.Length, numSum = nums.Sum();
        for (int i = 0; i < n; i++) {
            f += i * nums[i];
        }
        int res = f;
        for (int i = n - 1; i > 0; i--) {
            f += numSum - n * nums[i];
            res = Math.Max(res, f);
        }
        return res;
    }
}

###C++

class Solution {
public:
    int maxRotateFunction(vector<int>& nums) {
        int f = 0, n = nums.size();
        int numSum = accumulate(nums.begin(), nums.end(), 0);
        for (int i = 0; i < n; i++) {
            f += i * nums[i];
        }
        int res = f;
        for (int i = n - 1; i > 0; i--) {
            f += numSum - n * nums[i];
            res = max(res, f);
        }
        return res;
    }
};

###C

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int maxRotateFunction(int* nums, int numsSize){
    int f = 0, numSum = 0;
    for (int i = 0; i < numsSize; i++) {
        f += i * nums[i];
        numSum += nums[i];
    }
    int res = f;
    for (int i = numsSize - 1; i > 0; i--) {
        f += numSum - numsSize * nums[i];
        res = MAX(res, f);
    }
    return res;
}

###JavaScript

var maxRotateFunction = function(nums) {
    let f = 0, n = nums.length, numSum = _.sum(nums);
    for (let i = 0; i < n; i++) {
        f += i * nums[i];
    }
    let res = f;
    for (let i = n - 1; i > 0; i--) {
        f += numSum - n * nums[i];
        res = Math.max(res, f);
    }
    return res;
};

###go

func maxRotateFunction(nums []int) int {
    numSum := 0
    for _, v := range nums {
        numSum += v
    }
    f := 0
    for i, num := range nums {
        f += i * num
    }
    ans := f
    for i := len(nums) - 1; i > 0; i-- {
        f += numSum - len(nums)*nums[i]
        ans = max(ans, f)
    }
    return ans
}

func max(a, b int) int {
    if b > a {
        return b
    }
    return a
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。计算 $\textit{numSum}$ 需要 $O(n)$ 时间，计算初始值 $F(0)$ 也需要 $O(n)$ 时间，因为我们只需遍历一次数组。之后，我们进行 $n - 1$ 次迭代来计算 $F(k)$ 的其余值。每次迭代使用递推关系式更新值：

  $$
  F(k) = F(k-1) + \textit{numSum} - n \cdot \textit{nums}[n-k]
  $$

  此更新仅涉及常数数量的算术运算，因此每次迭代的时间复杂度为 $O(1)$。因此，总的时间复杂度为：

  $$
  O(n) + O(n) + O(n) = O(n)
  $$

  总体而言，该算法的时间复杂度为线性。

• 空间复杂度：$O(1)$。仅使用常数空间。

解题思路

推导过程：
（1）F(k) = 0 * Bk[0] + 1 * Bk[1] + ... + (n-2) * Bk[n-2] + (n-1) * Bk[n-1]
（2）F(k+1) = 0 * Bk[n-1] + 1 * Bk[0] + 2 * Bk[2] + ... + (n-1) * Bk[n-2]
（2）-（1）得：F(k+1) - F(k) = (Bk[0] + Bk[1] + ... + Bk[n-2]) - (n-1)*Bk[n-1]
可得：F(k+1) - F(k) = (Bk[0] + Bk[1] + ... + Bk[n-2] + Bk[n-1]) - n*Bk[n-1]
令S=Sum{Bk}
有：F(k+1) = F(k) + S - n * Bk[n-1]

代码

###cpp

class Solution {
public:
    int maxRotateFunction(vector<int>& A) {
        long N = A.size();
        long S = 0;
        long t = 0;
        for (int i = 0; i < N; ++i) {
            S += A[i];
            t += i * A[i];
        }
        long res = t;
        for (int i = N - 1; i >= 0; --i) {
            // F(k+1) = F(k) + S - n * Bk[n-1]
            t += S - N * (long)A[i];
            res = max(res, t);
        }
        return res;
    }
};

几乎每个上周去过北京车展的朋友，都会跟我说起，这次在梅赛德斯-奔驰的展区，感受到了一些特殊的气质。

这种气质首先来自审美。在当下新能源市场竞争空前激烈的背景下，过于追求原创和先锋设计几乎等同于和市场对着干。在这种环境下，奔驰带来的那些经典车型的设计，仍然会让人由衷地觉得百看不腻。

而在经典设计之外，今年梅奔在智能化领域更是带来了一系列突破。

在高阶辅助驾驶领域，全新交付的纯电 CLA 现已支持城区及高速辅助驾驶全国可用，年内力争实现「车位到车位」功能，一举从外界印象里的「传统燃油车」，变成一个也能上桌做压轴题的选手。

在座舱层面，梅奔中国研发团队主导在全新后排娱乐系统部署的 VLM 大模型，将带来更丰富的车内多模态感知和理解能力。用用梅赛德斯-奔驰集团股份公司首席软件官欧孟宇（Magnus Östberg）先生的话来说，这是一种「从容不迫」的智能化体验——不需要主动发出指令，技术也能通过主动且不打扰的方式服务用户。

据了解，这套由中国团队主导研发的全新后排娱乐系统，未来也将会输出到全球市场。

更为难得的是，无论是公开发布会还是私下媒体沟通里，梅奔内部从不讳言这些科技背后有来自中国的「供应链技术」——无论智驾合作伙伴 Momenta，还是座舱领域的伙伴字节、高德、清华、腾讯。这在如今强调「自研」和技术标签的车圈竞争里，也算是一股清流。

在北京车展媒体日，极客公园作者和其他 4 家媒体一起，和梅赛德斯-奔驰两位核心技术高管进行了一场对谈。我们从技术谈起，话题涉及产品功能、市场竞争、产业合作甚至关于 AI 时代商业合作范式的变化推演，以下为本场媒体对话的文字版。

其中，Q 代表媒体提问，M 代表两位梅奔高管的回答。两位受访者分别为：

• 梅赛德斯-奔驰集团股份公司首席软件官欧孟宇（Magnus Östberg）
• 梅赛德斯-奔驰（中国）投资有限公司执行副总裁、梅赛德斯-奔驰中国研发自动驾驶及车联网负责人王忻

问答均在保留原意的基础上，经过极客公园编辑整理。

梅奔首席软件官欧孟宇（Magnus Östberg） | 图片来源：梅赛德斯-奔驰

不拼参数的智能化体验

Q：AI 怎样落实到日常出行体验中？如何理解智能化和豪华之间的关系？

M：所谓的「数字豪华」，应该交付给用户一种「从容不迫」的体验。我们希望用户和车之间的交互形态，不仅是主动发出指令，技术也能以更自然、更主动、不打扰的方式服务用户。

举个例子，我们和清华大学联合打造的端侧 VLM 大模型将被应用在新一代 S 级轿车的智能座舱里。在那样一台长轴距的行政轿车后排，用户操控屏幕并不方便。系统可以通过对手势、视觉信息和多模态信号的理解，让交互变得更自然、更优雅。

Q：梅奔在车展宣布，新一代的 S 级轿车和新一代迈巴赫 S 级轿车上都搭载了城区领航辅助驾驶。这两款车的用户对舒适度要求可能比智能驾驶还高，你们怎么平衡这些需求？

M：这里其实有两个核心问题：第一，在燃油车上搭载高阶辅助驾驶；第二，在豪华车型上同时满足智能化和舒适化。

首先，燃油车和纯电动车在车辆动态特性上有很大不同，电机和内燃机的动力响应不同。因此，我们确实为此做了很多额外工作，确保燃油车上的辅助驾驶体验同样平顺、自然。

此外，燃油车的变速箱也会带来挑战。我们尽可能通过软件，把电动车上已经形成的调校曲线迁移过来。不可能完全一样，但我们会让它尽可能接近电动车上的体验。

所以，如果用户喜欢 V12 发动机的体验、喜欢 AMG，他们不需要在「智能」和「性能」之间做选择。这将是奔驰的一个重要差异。

新一代 S 级轿车上将搭载奔驰和 Momenta 共同开发的城区及高速领航辅助驾驶 | 图片来源：极客公园

中国主导，服务全球

Q：在中国市场，速度很重要；但奔驰又是一家对安全和标准非常谨慎的公司。这两者怎么平衡？

M：我们一直说的是「中国速度，奔驰标准」。中国市场变化很快，所以我们会更早地和本土战略合作伙伴共创，把新的想法做出来。但这些功能最终上车前，仍然要经过奔驰标准的测试和认证，确保按时、按质交付给用户。

Q：作为一家全球车企，梅奔中国和德国总部之间是如何分工以及配合的？

M：我们的标准很简单：如果某项功能在中国开发能够做得最快、最好，那就由中国团队引领。比如泊车功能就是由中国团队主导全球研发，全新高端后排娱乐系统也是先由中国团队完成，再服务全球市场。

由中国团队主导研发的全新高端后排娱乐系统 | 图片来源：梅赛德斯-奔驰

Q：但外界有一种担心：德国标准会不会让奔驰在中国市场显得慢半拍？

M：德国标准不是死板的规则，关键是理解它为什么存在。有些标准是安全红线，不能跨；但有些具体体验，可以结合中国道路和用户场景调整。比如辅助驾驶限速，我们既会遵守规则，也会参考高德提供的经验速度，以及车辆通过环境感知看到的车流速度，让系统更符合真实道路环境。

在研发过程里，我们会讨论什么样的「节奏」是最合适的。对于梅赛德斯-奔驰而言，安全承诺永远是第一位。因此，有时我们会有意把某些功能发布得稍晚一些，因为我们必须确保它符合奔驰的安全承诺。

Q：中国和欧洲在 AI 等新技术上的「时间差」，会不会给奔驰带来压力？

M：这是我们之所以要在中国设立研发团队的原因——我们喜欢中国的这种速度。

中国团队可以帮助我们把在中国实现的想法带向全球。当然，我们也可以把全球其他市场的优秀能力带到中国，这是双向的。

梅奔中国执行副总裁、研发自动驾驶及车联网负责人王忻 | 图片来源：梅赛德斯-奔驰

Q：过去 5 年，汽车智能化层面出现了非常多新的变量和名词。你们认为最核心的变化是什么？

M：过去几年最核心的变化也许不在产品功能，而是数字化。

我们在全球各个市场都建立了完整的数字化基础架构。有了这个基础架构，梅赛德斯-奔驰可以更全面了解客户如何使用车辆。

例如，我们会关注功能的使用率。如果某项功能使用率很高，说明它确实有价值；如果使用率很低，我们要判断到底是我们没做好，还是这个功能本身并不是用户真正需要的。我们希望每次提供的新功能，都是用户日常能用到的真需求。

AI 上车，不是 Token 竞赛

Q：奔驰有 140 年的历史，经历过很多技术变革。您认为这轮 AI 带来的技术变革，可以和汽车史上的哪一次重要技术变革进行类比？例如发动机电喷，或者汽车电子化？

M：我认为这不是只发生在汽车工业内部的变革，而是整个行业的变革。我认为 AI 革命的重要性，相当于人类第一次利用电力。而且这一次变化发生的速度，可能还要快 10 倍。

Q：过去几年，在中国市场谈到汽车「智能化」时，往往率先会提到一些智能驾驶公司。但今天奔驰提到了腾讯、字节跳动等互联网巨头。你们认为，随着 AI 爆发，下一步的商业形态和合作关系会发生哪些变化？

M：我认为现在是围绕 Token 的疯狂竞赛（mad race of Tokens）阶段。所以，大模型公司和硬件/芯片公司在这轮 Token 竞赛中获益最多。

但我预计，未来会有一些更聪明的解决方案出现，打破这种 Token 竞赛模式。奔驰关心的是技术能否真正给客户带来价值，而不是模型能生成多少 Token。因此，也许我们也会与一些新的 AI 初创公司合作。

Q：如果不是单纯拼模型和 Token，下一阶段车企和科技公司的合作核心会是什么？

M：数据可能会变得更重要。无论是语音、座舱，还是辅助驾驶，技术路线变化都会带来合作伙伴变化。

谁能提供更准确、更有用的数据，谁就可能改变合作方式。未来的合作关系，可能不只是采购一个模型或一个硬件，而是围绕数据掌握、数据使用和数据运营重新组织。

方法一：动态规划

思路与算法

题目要求我们在总花费不超过 $k$ 的情况下，找到一条从 $\textit{grid}[0][0]$ 到 $\textit{grid}[m-1][n-1]$ 的路径，使得获得的分数最大。这种有限制的最优化问题结构类似背包问题，可以用动态规划解决。

定义状态 $\textit{dp}[i][j][c]$ 表示到达位置 $(i,j)$，当前花费为 $c$ 时的最大得分。

我们从当前格子向后转移，即从 $(i,j)$ 出发，可以向下或向右移动，将下一个格子的代价和分数加入：

• 向下：转移到 $(i+1,j)$
• 向右：转移到 $(i,j+1)$

状态转移为：

$$
\begin{aligned}
\textit{dp}[i+1][j][c + \textit{cost}(i+1,j)] &= \max(\textit{dp}[i+1][j][c + \textit{cost}(i+1,j)],\textit{dp}[i][j][c] + \textit{grid}[i+1][j]) \
\textit{dp}[i][j+1][c + \textit{cost}(i,j+1)] &= \max(\textit{dp}[i][j+1][c + \textit{cost}(i,j+1)],\textit{dp}[i][j][c] + \textit{grid}[i][j+1])
\end{aligned}
$$

其中：

$$
\textit{cost}(i,j) =
\begin{cases}
1, & \textit{grid}[i][j] \neq 0 \
0, & \textit{grid}[i][j] = 0
\end{cases}
$$

初始状态为 $\textit{dp}[0][0][0] = 0$（起点不计入得分和花费）。

最终答案为：

$$
\max\limits_{0 \le c \le k} \textit{dp}[m-1][n-1][c]
$$

代码

###C++

class Solution {
public:
    int maxPathScore(vector<vector<int>>& grid, int k) {
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<vector<int>>> dp(
            m, vector<vector<int>>(n, vector<int>(k + 1, INT_MIN)));
        dp[0][0][0] = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int c = 0; c <= k; c++) {
                    if (dp[i][j][c] == INT_MIN)
                        continue;
                    if (i + 1 < m) {
                        int val = grid[i + 1][j];
                        int cost = (val == 0 ? 0 : 1);
                        if (c + cost <= k) {
                            dp[i + 1][j][c + cost] =
                                max(dp[i + 1][j][c + cost], dp[i][j][c] + val);
                        }
                    }
                    if (j + 1 < n) {
                        int val = grid[i][j + 1];
                        int cost = (val == 0 ? 0 : 1);
                        if (c + cost <= k) {
                            dp[i][j + 1][c + cost] =
                                max(dp[i][j + 1][c + cost], dp[i][j][c] + val);
                        }
                    }
                }
            }
        }
        int ans = INT_MIN;
        for (int c = 0; c <= k; c++) {
            ans = max(ans, dp[m - 1][n - 1][c]);
        }
        return ans < 0 ? -1 : ans;
    }
};

###Java

class Solution {
    public int maxPathScore(int[][] grid, int k) {
        int m = grid.length;
        int n = grid[0].length;

        int[][][] dp = new int[m][n][k + 1];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                Arrays.fill(dp[i][j], Integer.MIN_VALUE);
            }
        }

        dp[0][0][0] = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int c = 0; c <= k; c++) {
                    if (dp[i][j][c] == Integer.MIN_VALUE) continue;

                    if (i + 1 < m) {
                        int val = grid[i + 1][j];
                        int cost = (val == 0 ? 0 : 1);
                        if (c + cost <= k) {
                            dp[i + 1][j][c + cost] = Math.max(
                                dp[i + 1][j][c + cost],
                                dp[i][j][c] + val
                            );
                        }
                    }

                    if (j + 1 < n) {
                        int val = grid[i][j + 1];
                        int cost = (val == 0 ? 0 : 1);
                        if (c + cost <= k) {
                            dp[i][j + 1][c + cost] = Math.max(
                                dp[i][j + 1][c + cost],
                                dp[i][j][c] + val
                            );
                        }
                    }
                }
            }
        }

        int ans = Integer.MIN_VALUE;
        for (int c = 0; c <= k; c++) {
            ans = Math.max(ans, dp[m - 1][n - 1][c]);
        }

        return ans < 0 ? -1 : ans;
    }
}

###Python3

class Solution:
    def maxPathScore(self, grid, k):
        m, n = len(grid), len(grid[0])

        INF = float('-inf')
        dp = [[[INF] * (k + 1) for _ in range(n)] for _ in range(m)]
        dp[0][0][0] = 0

        for i in range(m):
            for j in range(n):
                for c in range(k + 1):
                    if dp[i][j][c] == INF:
                        continue

                    if i + 1 < m:
                        val = grid[i + 1][j]
                        cost = 0 if val == 0 else 1
                        if c + cost <= k:
                            dp[i + 1][j][c + cost] = max(
                                dp[i + 1][j][c + cost],
                                dp[i][j][c] + val
                            )

                    if j + 1 < n:
                        val = grid[i][j + 1]
                        cost = 0 if val == 0 else 1
                        if c + cost <= k:
                            dp[i][j + 1][c + cost] = max(
                                dp[i][j + 1][c + cost],
                                dp[i][j][c] + val
                            )

        ans = max(dp[m - 1][n - 1])
        return -1 if ans < 0 else ans

###C

int maxPathScore(int** grid, int m, int* gridColSize, int k) {
    int n = gridColSize[0];

    int*** dp = (int***)malloc(m * sizeof(int**));
    for (int i = 0; i < m; i++) {
        dp[i] = (int**)malloc(n * sizeof(int*));
        for (int j = 0; j < n; j++) {
            dp[i][j] = (int*)malloc((k + 1) * sizeof(int));
            for (int c = 0; c <= k; c++) {
                dp[i][j][c] = INT_MIN;
            }
        }
    }

    dp[0][0][0] = 0;

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int c = 0; c <= k; c++) {
                if (dp[i][j][c] == INT_MIN) continue;

                if (i + 1 < m) {
                    int val = grid[i + 1][j];
                    int cost = val == 0 ? 0 : 1;
                    if (c + cost <= k) {
                        int* target = &dp[i + 1][j][c + cost];
                        if (*target < dp[i][j][c] + val)
                            *target = dp[i][j][c] + val;
                    }
                }

                if (j + 1 < n) {
                    int val = grid[i][j + 1];
                    int cost = val == 0 ? 0 : 1;
                    if (c + cost <= k) {
                        int* target = &dp[i][j + 1][c + cost];
                        if (*target < dp[i][j][c] + val)
                            *target = dp[i][j][c] + val;
                    }
                }
            }
        }
    }

    int ans = INT_MIN;
    for (int c = 0; c <= k; c++) {
        if (dp[m - 1][n - 1][c] > ans)
            ans = dp[m - 1][n - 1][c];
    }

    return ans < 0 ? -1 : ans;
}

###Golang

func maxPathScore(grid [][]int, k int) int {
    m, n := len(grid), len(grid[0])

    const INF = math.MinInt32

    dp := make([][][]int, m)
    for i := range dp {
        dp[i] = make([][]int, n)
        for j := range dp[i] {
            dp[i][j] = make([]int, k+1)
            for c := range dp[i][j] {
                dp[i][j][c] = INF
            }
        }
    }

    dp[0][0][0] = 0

    for i := 0; i < m; i++ {
        for j := 0; j < n; j++ {
            for c := 0; c <= k; c++ {
                if dp[i][j][c] == INF {
                    continue
                }

                if i+1 < m {
                    val := grid[i+1][j]
                    cost := 0
                    if val != 0 {
                        cost = 1
                    }
                    if c+cost <= k {
                        if dp[i+1][j][c+cost] < dp[i][j][c]+val {
                            dp[i+1][j][c+cost] = dp[i][j][c] + val
                        }
                    }
                }

                if j+1 < n {
                    val := grid[i][j+1]
                    cost := 0
                    if val != 0 {
                        cost = 1
                    }
                    if c+cost <= k {
                        if dp[i][j+1][c+cost] < dp[i][j][c]+val {
                            dp[i][j+1][c+cost] = dp[i][j][c] + val
                        }
                    }
                }
            }
        }
    }

    ans := INF
    for c := 0; c <= k; c++ {
        if dp[m-1][n-1][c] > ans {
            ans = dp[m-1][n-1][c]
        }
    }

    if ans < 0 {
        return -1
    }
    return ans
}

###C#

public class Solution {
    public int MaxPathScore(int[][] grid, int k) {
        int m = grid.Length, n = grid[0].Length;

        int[,,] dp = new int[m, n, k + 1];

        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                for (int c = 0; c <= k; c++)
                    dp[i, j, c] = int.MinValue;

        dp[0, 0, 0] = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int c = 0; c <= k; c++) {
                    if (dp[i, j, c] == int.MinValue) continue;

                    if (i + 1 < m) {
                        int val = grid[i + 1][j];
                        int cost = val == 0 ? 0 : 1;
                        if (c + cost <= k) {
                            dp[i + 1, j, c + cost] = Math.Max(
                                dp[i + 1, j, c + cost],
                                dp[i, j, c] + val
                            );
                        }
                    }

                    if (j + 1 < n) {
                        int val = grid[i][j + 1];
                        int cost = val == 0 ? 0 : 1;
                        if (c + cost <= k) {
                            dp[i, j + 1, c + cost] = Math.Max(
                                dp[i, j + 1, c + cost],
                                dp[i, j, c] + val
                            );
                        }
                    }
                }
            }
        }

        int ans = int.MinValue;
        for (int c = 0; c <= k; c++) {
            ans = Math.Max(ans, dp[m - 1, n - 1, c]);
        }

        return ans < 0 ? -1 : ans;
    }
}

###JavaScript

var maxPathScore = function(grid, k) {
    const m = grid.length, n = grid[0].length;

    const INF = -Infinity;
    const dp = Array.from({ length: m }, () =>
        Array.from({ length: n }, () => Array(k + 1).fill(INF))
    );

    dp[0][0][0] = 0;

    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            for (let c = 0; c <= k; c++) {
                if (dp[i][j][c] === INF) continue;

                if (i + 1 < m) {
                    const val = grid[i + 1][j];
                    const cost = val === 0 ? 0 : 1;
                    if (c + cost <= k) {
                        dp[i + 1][j][c + cost] = Math.max(
                            dp[i + 1][j][c + cost],
                            dp[i][j][c] + val
                        );
                    }
                }

                if (j + 1 < n) {
                    const val = grid[i][j + 1];
                    const cost = val === 0 ? 0 : 1;
                    if (c + cost <= k) {
                        dp[i][j + 1][c + cost] = Math.max(
                            dp[i][j + 1][c + cost],
                            dp[i][j][c] + val
                        );
                    }
                }
            }
        }
    }

    let ans = Math.max(...dp[m - 1][n - 1]);
    return ans < 0 ? -1 : ans;
};

###TypeScript

function maxPathScore(grid: number[][], k: number): number {
    const m = grid.length, n = grid[0].length;

    const INF = -Infinity;
    const dp: number[][][] = Array.from({ length: m }, () =>
        Array.from({ length: n }, () => Array(k + 1).fill(INF))
    );

    dp[0][0][0] = 0;

    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            for (let c = 0; c <= k; c++) {
                if (dp[i][j][c] === INF) continue;

                if (i + 1 < m) {
                    const val = grid[i + 1][j];
                    const cost = val === 0 ? 0 : 1;
                    if (c + cost <= k) {
                        dp[i + 1][j][c + cost] = Math.max(
                            dp[i + 1][j][c + cost],
                            dp[i][j][c] + val
                        );
                    }
                }

                if (j + 1 < n) {
                    const val = grid[i][j + 1];
                    const cost = val === 0 ? 0 : 1;
                    if (c + cost <= k) {
                        dp[i][j + 1][c + cost] = Math.max(
                            dp[i][j + 1][c + cost],
                            dp[i][j][c] + val
                        );
                    }
                }
            }
        }
    }

    const ans = Math.max(...dp[m - 1][n - 1]);
    return ans < 0 ? -1 : ans;
}

###Rust

impl Solution {
    pub fn max_path_score(grid: Vec<Vec<i32>>, k: i32) -> i32 {
        let m = grid.len();
        let n = grid[0].len();
        let k = k as usize;

        let inf = i32::MIN / 2;
        let mut dp = vec![vec![vec![inf; k + 1]; n]; m];

        dp[0][0][0] = 0;

        for i in 0..m {
            for j in 0..n {
                for c in 0..=k {
                    if dp[i][j][c] == inf {
                        continue;
                    }

                    if i + 1 < m {
                        let val = grid[i + 1][j];
                        let cost = if val == 0 { 0 } else { 1 };
                        if c + cost <= k {
                            dp[i + 1][j][c + cost] =
                                dp[i + 1][j][c + cost].max(dp[i][j][c] + val);
                        }
                    }

                    if j + 1 < n {
                        let val = grid[i][j + 1];
                        let cost = if val == 0 { 0 } else { 1 };
                        if c + cost <= k {
                            dp[i][j + 1][c + cost] =
                                dp[i][j + 1][c + cost].max(dp[i][j][c] + val);
                        }
                    }
                }
            }
        }

        let mut ans = inf;
        for c in 0..=k {
            ans = ans.max(dp[m - 1][n - 1][c]);
        }

        if ans < 0 { -1 } else { ans }
    }
}

复杂度分析

• 时间复杂度：$O(mnk)$，其中 $m$，$n$ 分别是矩阵 $\textit{grid}$ 的行数和列数。
• 空间复杂度：$O(mnk)$。

你有没有想过一个问题：为什么 Canvas 里的文字永远那么丑？为什么游戏里的 UI 只能用 Canvas API 手画，而不能直接写个 <div> 上去？为什么每次做图表都要在 ctx.fillText 和 CSS 字体之间反复拉扯？今天，一个正在 Chromium 中孵化的 WICG 提案，要彻底终结这个延续了二十年的困局。

📋 目录

• 背景：Canvas 二十年的「盲人」困境
• 前传：为什么 Canvas 一直渲染不了 HTML
• 核心原语一：layoutsubtree——一纸委任状
• 核心原语二：drawElementImage——画布上的复印机
• 核心原语三：paint 事件——智能触发器
• Bonus：captureElementImage——通往 Worker 的传送门
• 深水区：事件循环中的时序博弈
• 同步公式：CSS Transform 背后的线性代数
• 隐私保护：看不见的边界
• 生态地图：谁已经上车了
• 未解之谜与未来方向
• 总结

背景：Canvas 二十年的「盲人」困境

2004 年，Apple 在 Safari 中引入了 <canvas> 元素，随后被 WHATWG 和 W3C 标准化。二十多年来，Canvas 成为 Web 上最强大的 2D/3D 图形基元——游戏、图表、数据可视化、创意工具、图像编辑……几乎一切"像素级别的操作"都跑在 Canvas 上。

但它有一个致命的短板：渲染不了真正的 HTML 内容。

这听起来像是一个不应该存在的问题——我明明有一个 <div>，为什么不能把它「画」到 Canvas 上？但现实是，开发者们二十年来的解决方案只有这些：

这些问题带来的连锁反应非常具体：

• 可访问性灾难：Canvas fallback 内容和实际画出来的像素，本质上没有约束关系。开发者写了一个披着 aria-label 外衣的 <canvas>，但里面到底画了什么，屏幕阅读器和实际视觉内容完全是两套。
• 国际化短板：ctx.fillText 不处理 RTL（阿拉伯语/希伯来语）、竖排文字、复杂脚本连字。如果你的图表需要显示阿拉伯语标签，要么自己实现排版引擎，要么放弃。
• 游戏 UI 的割裂：3D 场景中的 2D 界面（菜单、对话气泡、HUD），要么用 3D 引擎的内置 UI 系统（学习成本高），要么用 Canvas 手绘（质量差），要么用 DOM 覆盖层（无法与 3D 场景融合）。

HTML-in-Canvas 提案的目标就是：让开发者能把真正的 DOM 元素渲染到 Canvas 上，用浏览器的原生排版引擎干活。

前传：为什么 Canvas 一直渲染不了 HTML

在深入 API 之前，先搞明白一个核心问题：为什么这件事以前做不到？

浏览器的渲染流水线大致是这样的：

JS → Style → Layout → Paint → Composite

• Style：计算 CSS 规则
• Layout：计算盒模型位置
• Paint：生成绘制指令列表（display list）
• Composite：合成图层

Canvas 的渲染是脱离这个流水线的。Canvas 的内容通过 JS 调用 Canvas API（fillRect、drawImage 等）写入一个位图缓冲区，然后直接作为一个纹理交给 GPU。浏览器的渲染引擎（Paint/Composite）对 Canvas 内部发生了什么一无所知。

而 HTML 元素的渲染走的是完整的 Style → Layout → Paint → Composite 管道。

所以，要把 HTML 渲染到 Canvas 上，本质上是要让浏览器的渲染管道和 Canvas 的像素缓冲区之间建立一座桥——而且这座桥不能破坏安全模型，不能引入性能问题，还要支持可访问性。

这比听起来难得多。直到 WICG/html-in-canvas 提出了一套优雅的解决方案。

核心原语一：layoutsubtree——一纸「委任状」

提案的第一个原语是一个 HTML 属性——layoutsubtree。

<canvas id="myCanvas" layoutsubtree>
  <div id="myContent">
    <h2>Hello Canvas!</h2>
    <p>我可以在 Canvas 里用 HTML 渲染了！</p>
  </div>
</canvas>

加上这个属性的瞬间，发生了三件关键的事情：

1. Canvas 的子元素获得了 stacking context，成为了其后代元素的 containing block
2. Canvas 的子元素拥有了 paint containment（绘制包含）
3. Canvas 的子元素参与了正常布局和 hit testing

翻译成人话：Canvas 的孩子虽然还在 DOM 树里，但它们的视觉渲染被「截胡」了——浏览器的 Paint 阶段不会再把这些孩子渲染到屏幕上，而是把它们的绘制结果存起来，等着开发者用 API 取走。 同时，它们仍然参与布局、可访问性树和事件命中测试。

这个设计有一个非常精妙的双重角色：同一个元素既是视觉内容（被绘制到 Canvas 中），也是可访问性内容（作为 Canvas fallback）。不像现在的 <canvas> fallback——画出来的东西和 fallback 内容是两套，永远有不同步的风险。在 HTML-in-Canvas 中，它们就是同一个东西。

layoutsubtree 就像是一纸「委任状」：告诉浏览器「这些孩子交给我来画，但请帮我把它们的布局和绘制结果准备好。」

核心原语二：drawElementImage——画布上的「复印机」

有了 layoutsubtree 把布局和可访问性安排好，下一步就是把子元素「印」到 Canvas 上。这就是 drawElementImage()：

const ctx = canvas.getContext('2d');

canvas.onpaint = () => {
  ctx.reset();
  // 把 form_element 画到 Canvas 的 (100, 0) 位置
  const transform = ctx.drawElementImage(form_element, 100, 0);
  // 同步 DOM 位置
  form_element.style.transform = transform.toString();
};

核心行为：

• 只接受 Canvas 的直接子元素（这就是 layoutsubtree 标记的那些孩子）
• 调用时，返回一个 DOMMatrix（CSS transform 矩阵），你需要把这个矩阵应用到元素的 style.transform 上，让 DOM 位置和画上去的位置保持一致
• Canvas 的当前变换矩阵（CTM，Current Transformation Matrix）会作用于绘制——也就是说，你可以在画布上 ctx.rotate(45) 然后 drawElementImage，元素就会旋转
• 子元素的 CSS transform 被忽略（原因见下文——如果不忽略会导致双重变换）
• 溢出内容被裁切到元素的 border box

destination rect 参数（和 drawImage 一模一样）：

// 最简形式：在 (x, y) 处以原始尺寸绘制
ctx.drawElementImage(element, x, y);

// 指定目标尺寸
ctx.drawElementImage(element, x, y, width, height);

// 带 source rect 裁剪
ctx.drawElementImage(element, sx, sy, sw, sh, dx, dy, dw, dh);

WebGL 版本的接口是 texElementImage2D，把元素渲染到纹理：

// 当你需要把 HTML 内容作为 3D 纹理时
gl.texElementImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, myElement);

WebGPU 版本的接口是 copyElementImageToTexture：

queue.copyElementImageToTexture(myElement, destination);

一个 API，覆盖 2D Canvas、WebGL、WebGPU 三大图形上下文。

形象一点理解：drawElementImage 就像是把浏览器的渲染引擎当作一台复印机，你传一个 DOM 元素进去，它返回一页「复印件」——而且附带一个坐标映射表（DOMMatrix），告诉你怎么把这页「复印件」在画布上的位置同步给 DOM。

核心原语三：paint 事件——智能触发器

drawElementImage 画的是快照。问题来了：当元素的内容发生变化时（比如输入框里有文字输入），开发者怎么知道需要重新绘制？

这就是 paint 事件的用武之地：

canvas.addEventListener('paint', (event) => {
  // event.changedElements 包含渲染发生了变化的子元素
  ctx.reset();
  for (const el of event.changedElements) {
    const t = ctx.drawElementImage(el, 0, 0);
    el.style.transform = t.toString();
  }
});

关键特性：

1. 智能触发：只有当子元素的视觉渲染真正发生变化时才会触发，而不是 60fps 无脑循环。省电、省 CPU。
2. 时机：在浏览器每一帧渲染管线的 update-the-rendering 阶段中，紧跟在 intersection observer 步骤之后、Paint 步骤之前触发。

... → IntersectionObserver → paint event → Paint → Composite → ...

3. CSS transform 变化不触发：因为 transform 影响的是位置而非渲染内容，改变 transform 不会重新生成 paint 指令，所以不触发 paint 事件。
4. paint 内的 DOM 改动推迟到下一帧：你在 paint 回调里改了元素的 class/文本，这一帧不会生效，下一帧才会。
5. requestPaint()：如果你需要每帧都重绘（类似游戏循环），可以调用 canvas.requestPaint() 强制触发 paint 事件，行为和 requestAnimationFrame 类似。

Bonus：captureElementImage——通往 Worker 的传送门

有一个问题：上面的所有 API 都依赖 DOM 元素引用，但 Web Worker 中无法访问 DOM。

解决方案是 captureElementImage()：

// 主线程：捕获快照并传送到 Worker
canvas.onpaint = () => {
  const elementImage = canvas.captureElementImage(form_element);
  worker.postMessage({ elementImage }, [elementImage]);  // Transferable！
};

// Worker：直接绘制
self.onmessage = (e) => {
  if (e.data.elementImage) {
    ctx.drawElementImage(e.data.elementImage, 100, 0);
  }
};

ElementImage 是一个 Transferable 对象，和 ImageBitmap、ArrayBuffer 一样，支持零拷贝传输。这为 OffscreenCanvas 在 Worker 中高性能渲染 HTML 内容铺平了道路。

整个对象只有三个方法/属性：

• width / height：快照的尺寸
• close()：释放资源

轻量、简洁、高效。

深水区：事件循环中的时序博弈

如果说前面的 API 是"皮毛"，那下面这部分才是 HTML-in-Canvas 最深的设计决策——paint 事件到底应该在哪一刻触发？

规范文档中记录了三种方案，我们逐一分析：

Option A：在 ResizeObserver 时机触发（带循环）

位置：在 update-the-rendering 流程的第 16.2.6 步（Deliver resize observations），如果 paint 事件中又修改了样式，就循环回到第 16.2.1 步（Recalculate styles and update layout）。

问题：

• 需要在这个时间点同步执行 Paint 步骤来生成子元素的绘制快照。Paint 本身很消耗性能，还要可能跑多次。
• Gecko（Firefox 的渲染引擎）的架构导致了这里实现困难——某些引擎在这个时间点根本拿不到完整的绘制结果。
• 最致命的问题：WebGL。WebGL 的 gl.getError()、gl.getParameter() 等 API 需要触发 GPU 命令缓冲区刷新（flush），如果在 Paint 完成之前调用，会导致死锁或不一致的渲染状态。

Option B：紧接在 Paint 步骤之后触发（带循环）

位置：在浏览器的 Paint 步骤完成后立即触发。

优势：不需要上面那种"同步 Paint Canvas 子元素"的操作——因为 Paint 已经跑完了，每个元素的绘制结果是可用的。

问题：仍然需要循环。如果 paint event 中改动了 DOM，又得回退到 style recalc → layout → paint 的完整循环，可能在一次帧中跑多次，十分昂贵。

Option C：紧接在 Paint 步骤之后触发（不循环）—— 被选中的方案

核心思想：paint event 在一帧中只跑一次。

如果开发者在 paint event 中修改了 DOM？改了就改了，但这一帧已经锁死了——DOM 修改的效果留到下一帧的渲染管线去处理。

这带来一个非常有趣的对称性：浏览器的 Paint 步骤也是不可循环的——你无法在一个帧内让浏览器画两次。paint event 的行为和浏览器原生的 Paint 步骤完全对齐。

方案  |  循环  |  是否需要同步 Paint  |  兼容 WebGL  |  复杂度
A     |  是    |  是                  |  否（死锁）  |  高
B     |  是    |  否                  |  是          |  高
C     |  否    |  否                  |  是          |  低 ✅

这个决策过程是 HTML-in-Canvas 提案中最精妙的设计之一。它不强求"开发者改了我就立刻刷新"，而是承认一帧内做到绝对实时是不现实的，通过"延迟到下一帧"来换取架构的简洁性和跨浏览器兼容性。

就像 React 的虚拟 DOM 不追求"每次修改立刻更新真实 DOM"一样，HTML-in-Canvas 也不追求"每个 CSS 变化都立刻刷新 Canvas 绘制"。延迟带来一致性。

同步公式：CSS Transform 背后的线性代数

前面提到，drawElementImage() 返回一个 DOMMatrix，需要设置到元素的 style.transform 上。为什么要这么做？

因为浏览器的 hit testing（点击命中测试）、intersection observer、可访问性功能都依赖元素的 DOM 位置。如果你把一个 <div> 画到了 Canvas 的 (100, 200) 位置，但它在 DOM 树中还在原始位置，点击 (100, 200) 就命中不了这个元素。

解决方案是：把 DOM 元素通过 CSS transform 移动到与绘制位置匹配。

drawElementImage() 返回的 DOMMatrix 就是按如下公式计算的：

T_sync = T_origin⁻¹ · S_css→grid⁻¹ · T_draw · S_css→grid · T_origin

其中：

• T_draw：绘制到 Canvas 上的变换矩阵，等于 CTM · T(x, y) · S(destScale)（CTM + 位置偏移 + 缩放）
• T_origin：元素的 transform-origin 矩阵
• S_css→grid：CSS 像素到 Canvas 网格像素的缩放矩阵

直观理解：这个公式做的事情就是把"在 Canvas 网格坐标系中的绘制位置"反向映射回"DOM 中的 CSS 像素位置"。

对于 WebGL/WebGPU 中的 3D 场景，还有一个辅助方法 canvas.getElementTransform(element, drawTransform)，让你传入任意变换矩阵并计算出对应的 CSS transform。

// 2D Canvas 直接返回
const transform = ctx.drawElementImage(element, x, y);

// WebGL/WebGPU 需要手动计算
const drawTransform = new DOMMatrix([...]); // 你自定义的 3D 变换
const cssTransform = canvas.getElementTransform(element, drawTransform);
element.style.transform = cssTransform.toString();

重要提醒：CSS transform 的变化不会触发 paint 事件——因为 transform 只影响位置，不影响绘制内容，所以 paint event 不会因为你在同步 transform 而反复触发。这避免了死循环。

隐私保护：看不见的边界

drawElementImage() 能让 Canvas 读取 DOM 元素的像素，这就带来了一个安全问题：如果 Canvas 能读取任何元素的内容，那跨域保护怎么办？

提案的隐私模型遵循一个核心理念：drawElementImage 不会暴露任何 JavaScript 当前不可访问的信息。 换句话说，它不会打开新的攻击面。

被排除在绘制之外的敏感内容：

不被视为敏感（允许绘制）的内容：

注意：这是预防性设计——在提案还处于 WICG 孵化阶段就考虑了完整的安全模型。这与 W3C TAG 审查（issue #1204）和 WHATWG 标准化讨论中的安全关注点保持一致。

生态地图：谁已经上车了

虽然提案还在孵化中，浏览器端只有 Chrome Canary 和 Brave Stable (Chromium 147+) 通过 flag 支持，但开源社区已经在积极适配：

three.js — 原生 WebGL 纹理集成

mrdoob/three.js 已经在 WebGL 和 WebGPU 两个渲染后端中集成了 HTML-in-Canvas：

// three.js 内部实现（简化）
if ('texElementImage2D' in gl) {
  const canvas = gl.canvas;
  if (!canvas.hasAttribute('layoutsubtree')) {
    canvas.setAttribute('layoutsubtree', 'true');
  }
  // HTML 元素直接作为纹理源
  gl.texElementImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, htmlElement);
}

这意味你可以把任意的 HTML 内容作为 three.js 的纹理，直接贴到 3D 模型上。

相关 PR: mrdoob/three.js#31233

PlayCanvas — 3D 产品配置器 + HtmlSync

PlayCanvas 引擎甚至在官方示例中完整实现了基于 HTML-in-Canvas 的交互式 3D 产品配置器。一个 HTML 面板被渲染为 WebGL 纹理，用户点击 3D 场景中的 HTML 按钮时的 hit testing 完全由浏览器的原生 DOM 事件处理——通过 getElementTransform 同步位置。

关键助手类 HtmlSync 被设计为可复用的工具类，处理 canvas ↔ 3D 平面的坐标映射。

VFX-JS — 视觉特效框架

fand/vfx-js 提供了一个优雅的 addHTML() 方法：

const vfx = new VFX();
await vfx.addHTML(element, { shader: 'liquidGlass' });

它内部先检查 supportsHtmlInCanvas()，如果可用就使用原生 API，否则优雅降级到传统的 dom-to-canvas 方案——渐进增强的最佳实践。

three-html-render — 纯 JS Polyfill

最令人兴奋的生态项目之一是 repalash/three-html-render——一个在浏览器不支持原生 API 时的 Polyfill。它通过 CSS matrix3d() 变换和 iframe / embed 技术模拟了 drawElementImage 的核心行为。

即使你的用户没有启用 chrome://flags/#canvas-draw-element，这个 Polyfill 也能工作。这是一个很聪明的策略——用 Polyfill 降低采用门槛，让框架生产环境可用。

未解之谜与未来方向

提案仍处于活跃讨论中（仓库中有 16 个 open issues），以下几个话题值得关注：

Open Issues 选读

未来：自动更新 Canvas

规范文档中提到了一个令人兴奋的未来方向——auto-updating canvas。

目前的模型是：你在 paint 事件中调用 drawElementImage，浏览器绘制快照。但如果支持了「自动更新模式」，drawElementImage 会在 Canvas 的命令缓冲区中记录一个"占位符"，浏览器可以在滚动或动画更新时自动重新执行绘制，无需阻塞 JS 主线程。

这意味着 Canvas 中的 HTML 内容可以和原生滚动完美同步，不再受 JS 事件循环的延迟影响。这个模式对 2D Canvas 已可行，对 WebGPU 也只需少量 API 扩展。

标准化进程

提案正处于标准化流程的以下位置：

WICG 孵化（当前）→ WHATWG Stage 2 → WHATWG Standard → 浏览器默认启用

• WHATWG Spec PR: #11588
• W3C TAG 早期审查: #1204（2026年3月启动）
• 跨浏览器共识：Chromium / Gecko / WebKit 已在设计上达成一致（paint 事件 Option C 时序）

总结

HTML-in-Canvas 不只是 Canvas 的一个新功能——它是 Web 图形平台二十年来最重要的一次基础能力补全。

它的核心贡献不是加了几个 API，而是在浏览器的渲染流水线和 Canvas 的像素缓冲区之间，架起了一座精心设计的桥梁：

• layoutsubtree 用属性声明边界
• drawElementImage 用返回值解决同步
• paint 用精妙的时序设计避免死循环和性能灾难
• captureElementImage 用 Transferable 搞定 Worker 并行

Three primitives + one helper，四个接口把"把 DOM 渲染到 Canvas"从不可能变成了可能——而且是在不破坏现有安全模型、不影响性能、保持可访问性的前提下。

三个核心判断：

1. 技术设计质量很高：从事件时序的选择（Option C）到隐私模型的预防性设计，到 drawElementImage 的返回值用作 style.transform，每个决策都有清晰的权衡分析。这不是一个"先上线再说"的功能。

2. 生态已经开始拥抱：three.js、PlayCanvas、VFX-JS 等知名图形项目的积极适配远超预期。尤其在 3D 游戏和可视化领域，需求非常强烈。

3. 还有一段路要走：目前只在 Chromium flag 后可用，Firefox 和 Safari 还没有明确的实现计划。标准化进程仍在 WICG 阶段。

如果你是图形/可视化方向的开发者，建议立刻打开 Chrome Canary，启用 chrome://flags/#canvas-draw-element，跑一下官方 Demo。虽然它还不是正式标准，但方向已经明确——而且这个方向，可能改变前端图形生态的底层逻辑。

关注 【iDao技术魔方】，获取更多全栈到AI可落地的实战干货。