诺贝尔奖也“擦边“：物理学不存在了.jpg

宫水三叶的刷题日记

于 2024-10-10 09:16:49 发布

阅读量485

点赞数 6

文章标签：后端

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

版权

诺贝尔物理奖

昨天，瑞典皇家科学院宣布将 2024 年诺贝尔物理学奖授予 John J. Hopfield 和 Geoffrey E. Hinton，以表彰他们在使用人工神经网络实现机器学习方面奠基性发现和发明。

得奖者是强者没错，但他们是计算机科学家呀，这是诺贝尔物理奖拿错了图灵奖的名单了吗 🤣🤣🤣

震惊的不止是网友，连得奖者之一的 Geoffrey E. Hinton 都一脸懵逼，直言道："我也完全没想到会发生这种事"。

面对铺天盖地的质疑，诺贝尔奖官方不得不在 X（前推特）上回应：

我直接好家伙。

AI，尤其是神经网络的进步，确实对物理学研究产生了巨大且深远的影响，但本身这并不属于物理学研究成果啊。

物理学已经没人到这地步了吗？

这么搞下去，诺贝尔物理奖也和雨果奖（关键字：海漄《时空画师》）差得不远了。

有些获奖，是得奖者的荣誉，但有些获奖，是这个奖本身的荣誉。

经过如此草台的一出闹剧，未来即使诺贝尔物理奖颁发给了真正的物理学家，也只能是获奖者来增加诺贝尔奖的含金量，而不能成为获奖者的荣誉。

对此，你怎么看？

...

回归主题。

来一道 HOT 100 级别的题目。

题目描述

平台：LeetCode

题号：150

根据逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = ["2","1","+","3","*"]

输出：9

解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]

输出：6

解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]

输出：22

解释：
该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

tokens[i] 要么是一个算符（ "+"、 "-"、 "*" 或 "/"），要么是一个在范围内的整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。

基本思路

这是一道关于「表达式计算」的题目。

所有的「表达式计算」问题都离不开「栈」。

对于本题，我们可以建立一个「数字栈」，存放所有的数字，当遇到运算符时，从栈中取出两个数进行运算，并将结果放回栈内，整个过程结束后，栈顶元素就是最终结果。

而栈的实现通常有两种：使用数组继续模拟 & 使用系统自带的栈结构

Java 代码（自带栈）：

class Solution {
    public int evalRPN(String[] ts) {
        Deque<Integer> d = new ArrayDeque<>();
        for (String s : ts) {
            if ("+-*/".contains(s)) {
                int b = d.pollLast(), a = d.pollLast();
                d.addLast(calc(a, b, s));
            }  else {
                d.addLast(Integer.parseInt(s));
            }
        }
        return d.pollLast();
    }
    int calc(int a, int b, String op) {
        if (op.equals("+")) return a + b;
        else if (op.equals("-")) return a - b;
        else if (op.equals("*")) return a * b;
        else if (op.equals("/")) return a / b;
        else return -1;
    }
}

Java 代码（数组模拟栈）：

class Solution {
    public int evalRPN(String[] ts) {
        int[] d = new int[ts.length];
        int tt = -1;
        for (String s : ts) {
            if ("+-*/".contains(s)) {
                int b = d[tt--], a = d[tt--];
                d[++tt] = calc(a, b, s);
            } else {
                d[++tt] = Integer.parseInt(s);
            }
        }
        return d[tt];
    }
    int calc(int a, int b, String op) {
        if (op.equals("+")) return a + b;
        else if (op.equals("-")) return a - b;
        else if (op.equals("*")) return a * b;
        else if (op.equals("/")) return a / b;
        else return -1;
    }
}

C++ 代码（数组模拟栈）：

class Solution {
public:
    int evalRPN(vector<string>& ts) {
        vector<int> d(ts.size());
        int tt = -1;
        for (string& s : ts) {
            if (s.size() == 1 && (s[0] == '+' || s[0] == '-' || s[0] == '*' || s[0] == '/')) {
                int b = d[tt--], a = d[tt--];
                d[++tt] = calc(a, b, s);
            } else {
                d[++tt] = stoi(s);
            }
        }
        return d[tt];
    }
    int calc(int a, int b, const string& op) {
        if (op == "+") return a + b;
        if (op == "-") return a - b;
        if (op == "*") return a * b;
        if (op == "/") return a / b;
        return -1;
    }
};

Python 代码（数组模拟栈）：

class Solution:
    def evalRPN(self, ts):
        d = [0] * len(ts)
        tt = -1
        for s in ts:
            if s in "+-*/":
                b = d[tt]
                tt -= 1
                a = d[tt]
                tt -= 1
                d[tt + 1] = self.calc(a, b, s)
                tt += 1
            else:
                d[tt + 1] = int(s)
                tt += 1
        return d[tt]

    def calc(self, a, b, op):
        if op == '+': return a + b
        elif op == '-': return a - b
        elif op == '*': return a * b
        elif op == '/': return int(a / b)
        else: return -1