凌晨重磅！ChatGPT 今天起免登录使用

发表于

GPT 3.5 免登录使用

今日凌晨，OpenAI 宣布，ChatGPT 无需登录就能使用。

一直以来，GPT 3.5 都是注册账号，就能免费使用，只有 GPT 4 才是需要花钱订阅。

但即使只是注册账号，对于中国大陆用户来说，也是不少的麻烦。

需要科学上网不说，注册 OpenAI 还需要海外手机收短信验证码，这一度让「直接售卖 GPT 账号」和「短信打码服务二房东」成为了一门生意。

如今，OpenAI 取消了登录使用限制，让国内使用 GPT 的难度下降到访问 Google 的级别。

大家只要打开浏览器访问 chat.openai.com 即可使用 ChatGPT 3.5。

红色输入框里，填入你想问的问题，回车

需要注意的是：由于是非登录下使用 GPT，因此所有上下文会在刷新浏览器后消失。

因此这种免登录使用 GPT 的模式，更适合偶尔临时使用。

另外不知道是不是错觉，虽然和登录状态下的 GPT 数据截止日期一致，但总感觉非登录状态下的 GPT 更”笨”一些：

非登录状态

登录状态

但无论如何，降低使用门槛总是好的，你觉得呢？

…

回归主线。

来做一道和「美团」二面相关的算法原题。

题目描述

平台：LeetCode

题号：108

给你一个整数数组 nums，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 111 」的二叉树。

示例 1：

1
2
3
4
5
ini复制代码输入：nums = [-10,-3,0,5,9]

输出：[0,-3,9,-10,null,5]

解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

1
2
3
4
5
ini复制代码输入：nums = [1,3]

输出：[3,1]

解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：

  • 1<=nums.length<=1041 <= nums.length <= 10^41<=nums.length<=104
  • −104<=nums[i]<=104-10^4 <= nums[i] <= 10^4−104<=nums[i]<=104
  • nums 按严格递增顺序排列

递归分治

题目给定的 nums 严格有序，为满足构造出来的 BST 整体平衡，我们需要保证每个子树的构造也是平衡的。

一个容易想到的思路：使用 nums 中最靠近中心的位置作为整棵 BST 的根节点，例如下标 mid=⌊l+r2⌋mid = \left \lfloor \frac{l + r}{2} \right \rfloormid=⌊2l+r⌋ 的位置，确保左右子树节点数量平衡。随后递归构造 nums 中下标范围为 [0,mid−1][0, mid - 1][0,mid−1] 作为左子树，递归构造 nums 中下标范围为 [mid+1,n−1][mid + 1, n - 1][mid+1,n−1] 作为右子树。

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
Java复制代码class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return build(nums, 0, nums.length - 1);
    }
    TreeNode build(int[] nums, int l, int r) {
        if (l > r) return null;
        int mid = l + r >> 1;
        TreeNode ans = new TreeNode(nums[mid]);
        ans.left = build(nums, l, mid - 1);
        ans.right = build(nums, mid + 1, r);
        return ans;
    }
}

Python 代码：

1
2
3
4
5
6
7
8
9
10
11
12
Python复制代码class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        return self.build(nums, 0, len(nums) - 1)

    def build(self, nums, l, r):
        if l > r:
            return None
        mid = l + r >> 1
        ans = TreeNode(nums[mid])
        ans.left = self.build(nums, l, mid - 1)
        ans.right = self.build(nums, mid + 1, r)
        return ans

C++ 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
C++复制代码class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return build(nums, 0, nums.size() - 1);
    }
    TreeNode* build(vector<int>& nums, int l, int r) {
        if (l > r) return nullptr;
        int mid = l + r >> 1;
        TreeNode* ans = new TreeNode(nums[mid]);
        ans->left = build(nums, l, mid - 1);
        ans->right = build(nums, mid + 1, r);
        return ans;
    }
};

TypeScript 代码：

1
2
3
4
5
6
7
8
9
10
11
TypeScript复制代码function sortedArrayToBST(nums: number[]): TreeNode | null {
    const build = function (nums: number[], l: number, r: number): TreeNode | null {
        if (l > r) return null;
        const mid = l + r >> 1;
        const ans = new TreeNode(nums[mid]);
        ans.left = build(nums, l, mid - 1);
        ans.right = build(nums, mid + 1, r);
        return ans;
    }
    return build(nums, 0, nums.length - 1);
};
  • 时间复杂度：O(n)O(n)O(n)
  • 空间复杂度：O(n)O(n)O(n)

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%