倒计时，世纪之谜将被“揭晓“

宫水三叶的刷题日记

于 2024-10-07 15:53:31 发布

阅读量376

点赞数 6

文章标签：后端

本文链接：https://blog.csdn.net/weixin_33243821/article/details/142741756

版权

世纪之谜

要说最近墙外的世界有什么火热话题？

HBO 将要上映的纪录片《Money Electric: The Bitcoin Mystery》（电子货币:比特币之谜）算是一个。

10月3日，纪录片导演 Cullen Hoback 和 HBO 重磅宣布纪录片《Money Electric：The Bitcoin Mystery》会于10月8日上映，片中将会曝光比特币背后的缔造者「中本聪（Satoshi Nakamoto）」的真实身份。

中本聪，是比特币创始人的化名，真实身份无人知晓。

他早期通过挖矿，手握 100W 枚比特币（占总量的 5%），以最新价格 63W 美元一枚计算，价值 600 多亿美元。

链上所有数据都是公开的，这些原始钱包自 2011 年之后就没有发生过任何交易，因此主流的猜测是中本聪已经去世，他所持有的比特币也不会再流通。

否则你很难想象，一个正常人面对一座金矿 13 年，完全不为所动。

不管 HBO 将要曝光的这位人士，是否为真实世界的中本聪，海外网友都已经聊嗨了，纷纷对中本聪的身份进行下注：

目前领跑榜单的是一位叫 Len Sassaman 的大叔，这是位密码学专家，不仅有多篇论文发表，还对一些知名隐私项目有过代码贡献。

但之所以能够领跑榜单，是因为他在 2011 年 7 月因抑郁症自杀，和中本聪原始钱包的静止时间比较接近。

关于 HBO 这事儿，怎么说呢。

首先很有意思，但我真不觉得片中能提出（毫无争议的）实锤类证据。

但这纪录片只要上映，就注定要成为比特币历史上的里程碑。

因为这是首次的，从公开角度去"曝光"一个无人知晓的身份，HBO 的做法太聪明了。

首先，本身一个无人知晓的身份，你无法从正面角度去推翻 HBO 的推测。

除非，HBO 猜测是中本聪已去世，但在 HBO 的纪录片上映之后，中本聪的钱包动了...

那 HBO 纪录片的地位将会是「加密货币史诗级大地震」的导火线，此时虽然 HBO 猜错，但已不重要了，核弹都炸了，谁还管是不是错点。

因而，HBO 猜没猜中，《Money Electric: The Bitcoin Mystery》都注定要赢。

...

回归主题。

不知道大伙的国庆假期什么时候结束呀？来一道小小算法题。

题目描述

平台：LeetCode

题号：1190

给出一个字符串 s（仅含有小写英文字母和括号）。

请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。

注意，您的结果中不应包含任何括号。

示例 1：

输入：s = "(abcd)"

输出："dcba"

示例 2：

输入：s = "(u(love)i)"

输出："iloveu"

示例 3：

输入：s = "(ed(et(oc))el)"

输出："leetcode"

示例 4：

输入：s = "a(bcdefghijkl(mno)p)q"

输出："apmnolkjihgfedcbq"

提示：

s 中只有小写英文字母和括号
我们确保所有括号都是成对出现的

双端队列

根据题意，我们可以设计如下处理流程：

从前往后遍历字符串，将不是 ) 的字符串从「尾部」放入队列中
当遇到 ) 时，从队列「尾部」取出字符串，直到遇到 ( 为止，并对取出字符串进行翻转
将翻转完成后字符串重新从「尾部」放入队列
循环上述过程，直到原字符串全部出来完成
从队列「头部」开始取字符，得到最终的答案

可以发现，上述过程需要用到双端队列（或者栈，使用栈的话，需要在最后一步对取出字符串再进行一次翻转）。

在 Java 中，双端队列可以使用自带的 ArrayDeque，也可以直接使用数组进行模拟。

Java 代码（使用 ArrayDeque ）：

class Solution {
    public String reverseParentheses(String s) {
        int n = s.length();
        char[] cs = s.toCharArray();
        Deque<Character> d = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            char c = cs[i];
            if (c == ')') {
                StringBuilder path = new StringBuilder();
                while (!d.isEmpty()) {
                    if (d.peekLast() != '(') {
                        path.append(d.pollLast());
                    } else {
                        d.pollLast();
                        for (int j = 0; j < path.length(); j++) d.addLast(path.charAt(j));
                        break;
                    }
                }
            } else {
                d.addLast(c);
            }
        }
        StringBuilder sb = new StringBuilder();
        while (!d.isEmpty()) sb.append(d.pollFirst());
        return sb.toString();
    }
}

Java 代码（数组模拟双端队列）：

class Solution {
    int N = 2010, he = 0, ta = 0;
    char[] d = new char[N], path = new char[N];
    public String reverseParentheses(String s) {
        int n = s.length();
        char[] cs = s.toCharArray();
        for (int i = 0; i < n; i++) {
            char c = cs[i];
            if (c == ')') {
                int idx = 0;
                while (he < ta) {
                    if (d[ta - 1] == '(' && --ta >= 0) {
                        for (int j = 0; j < idx; j++) d[ta++] = path[j];
                        break;
                    } else {
                        path[idx++] = d[--ta];
                    }
                }
            } else {
                d[ta++] = c;
            }
        }
        StringBuilder sb = new StringBuilder();
        while (he < ta) sb.append(d[he++]);
        return sb.toString();
    }
}

C++ 代码（数组模拟双端队列）：

class Solution {
public:
    string reverseParentheses(string s) {
        int N = 2010;
        vector<char> d(N), path(N);
        int he = 0, ta = 0;
        for (char c : s) {
            if (c == ')') {
                int idx = 0;
                while (he < ta) {
                    if (d[ta - 1] == '(' && --ta >= 0) {
                        for (int j = 0; j < idx; j++) d[ta++] = path[j];
                        break;
                    } else {
                        path[idx++] = d[--ta];
                    }
                }
            } else {
                d[ta++] = c;
            }
        }
        return string(d.begin(), d.begin() + ta);
    }
};

Python 代码（数组模拟双端队列）：

class Solution:
    def reverseParentheses(self, s: str) -> str:
        N, he, ta = 2010, 0, 0
        d, path = [''] * N, [''] * N
        for c in s:
            if c == ')':
                idx = 0
                while he < ta:
                    ta -= 1
                    if d[ta] == '(' and ta >= 0:
                        for j in range(idx):
                            d[ta] = path[j]
                            ta += 1
                        break
                    else:
                        path[idx] = d[ta]
                        idx += 1
            else:
                d[ta] = c
                ta += 1
        return ''.join(d[:ta])

TypeScript 代码（数组模拟双端队列）：

function reverseParentheses(s: string): string {
    let N = 201, he = 0, ta = 0;
    const d: string[] = new Array(N), path = new Array(N);
    for (let i = 0; i < s.length; i++) {
        let c = s.charAt(i);
        if (c === ')') {
            let idx = 0;
            while (he < ta) {
                if (d[ta - 1] === '(' && --ta >= 0) {
                    for (let j = 0; j < idx; j++) d[ta++] = path[j];
                    break;
                } else {
                    path[idx++] = d[--ta];
                }
            }
        } else {
            d[ta++] = c;
        }
    }
    return d.slice(0, ta).join('');
};

时间复杂度：每个 ( 字符只会进出队列一次； ) 字符串都不会进出队列，也只会被扫描一次；分析的重点在于普通字符，可以发现每个普通字符进出队列的次数取决于其右边的 ) 的个数，最坏情况下每个字符右边全是右括号，因此复杂度可以当做，但实际计算量必然取不满，将普通字符的重复弹出均摊到整个字符串处理过程，可以看作是每个字符串都被遍历常数次，复杂度为
空间复杂度：