一夜之间，深圳楼市行情爆了，房地产又回来了？

房地产救市

最近几天，最热闹的事情，是房地产又一次迎来核弹级的利好。

上周五（5月17日），国家正式落地几大利好政策：

• 下调首付：首套房首付比例降为 15%，二套房首付比例降为 25%
• 下调利率：个人住房公积金利率下调 0.25%
• 取消揭利率下限（利率政策底），权利下放至各级城市

消息是在盘中公布了，直接引爆了资本市场，万科保利双双涨停。

消息出来的当天，不少媒体认为，这几大政策可能将会扭转楼市趋势，让楼市重新具有"投资"价值。

接下来的两天周末，房地产市场也确实出现了久违的"躁动"：

• 网传过去的一个周末，北京二手房签约数量直接翻倍
• 上海、广州和杭州等热门城市，某壳统计的看房数量有较大激增
• 深圳出现连夜排队现象

虽然还没有实打实的成交数据，但二手房市场确实发生了一些微妙的变化：从「挂常规价格无人问津，上来先砍 20% 挂价」的纯买方市场，变为了「买家有兴趣成交，卖家犹豫是否要加价」的博弈局面。

我觉得，或许短期政策底到了，但是中长期的市场底远远没到。

衡量"房子是否值得购买"，话题太大，所谓的"值得与否"也因人而异。

那就干脆从"是否具备投资价值"的绝对理性角度去看待问题。

想要房子具有"投资"价值，最基本的，房屋的租售收入应该基本覆盖房贷的利息支出。

我们知道，在楼价疯涨的十年，利息普遍都在 5.5% 以上，同时租售比却在 2.5% 以下，只不过房价提供了远超 3% 的涨幅，所以买房的人才赢麻了。

也就是说，如果抹去房价涨幅，现实中，基本上是房东贴钱补贴租客的。

过去两年，租金涨幅变化不大，存量利率虽然进行了一波下降，但利息和租售收入，都还没拉平，如果叠加开倒车的房价，则更是惨烈。

带着「租售收入、房贷利息、房价变化」三者对比的角度去看待政策，你会发现，对前两者的影响几乎没有（本次下调的是公积金利率，而非商贷），如果要扭转局面，需要在「房价变化」的维度上，修复过去失地之余，提供平均 1.5% 以上的年涨幅，才能说房子具有"投资"价值。

对此，你怎么看呢？

你觉得即使 GDP 重回高速增长周期，我们还存在房价达到 1.5% 年涨幅的客观条件吗？

...

回归主线。

来一道和「华为 OD」相关的算法原题。

题目描述

平台：LeetCode

题号：801

我们有两个长度相等且不为空的整型数组 nums1 和 nums2。

在一次操作中，我们可以交换   和  的元素。

例如，如果 ， ，你可以交换 处的元素，得到 和 。

返回 使 nums1 和 nums2 严格递增 所需操作的最小次数 。

数组 arr 严格递增 且    。

注意：

用例保证可以实现操作。

示例 1:

输入: nums1 = [1,3,5,4], nums2 = [1,2,3,7]

输出: 1

解释: 
交换 A[3] 和 B[3] 后，两个数组如下:
A = [1, 3, 5, 7] ， B = [1, 2, 3, 4]
两个数组均为严格递增的。

示例 2:

输入: nums1 = [0,3,5,8,9], nums2 = [2,1,4,6,9]

输出: 1

提示:

基本分析

这是一道很裸的状态机 DP 运用题。

由于每次交换只会发生在两数组的相同位置上，使得问题变得简单：「仅需考虑交换当前位置后，当前元素与前后元素大小关系变化即可」。

又因为我们会从前往后处理每个位置，因此只需要考虑当前位置与前一位置的大小关系即可。

状态机 DP

定义 为考虑下标范围为 的元素，且位置 的交换状态为 时（其中 为不交换， 为交换）两数组满足严格递增的最小交换次数。

最终答案为 ，同时我们有显而易见的初始化条件 和 ，其余未知状态初始化为正无穷。

不失一般性考虑 该如何转移：

• 若 且 （即顺序位满足要求），此时要么当前位置 和前一位置 都不交换，要么同时发生交换，此时有（分别对应两个位置「都不交换」和「都交换」）：

• 若 且 （即交叉位满足要求），此时当前位置 和前一位置 只能有其一发生交换，此时有（分别对应「前一位置交换」和「当前位置交换」）：

Java 代码：

class Solution {
    public int minSwap(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int[][] f = new int[n][2];
        for (int i = 1; i < n; i++) f[i][0] = f[i][1] = n + 10;
        f[0][1] = 1;
        for (int i = 1; i < n; i++) {
            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
                f[i][0] = f[i - 1][0];
                f[i][1] = f[i - 1][1] + 1;
            }
            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
                f[i][0] = Math.min(f[i][0], f[i - 1][1]);
                f[i][1] = Math.min(f[i][1], f[i - 1][0] + 1);
            }
        }
        return Math.min(f[n - 1][0], f[n - 1][1]);
    }
}

C++ 代码：

class Solution {
public:
    int minSwap(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        vector<vector<int>> f(n, vector<int>(2, n + 10));
        f[0][0] = 0; f[0][1] = 1;
        for (int i = 1; i < n; ++i) {
            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
                f[i][0] = f[i - 1][0];
                f[i][1] = f[i - 1][1] + 1;
            }
            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
                f[i][0] = min(f[i][0], f[i - 1][1]);
                f[i][1] = min(f[i][1], f[i - 1][0] + 1);
            }
        }
        return min(f[n - 1][0], f[n - 1][1]);
    }
};

Python 代码：

class Solution:
    def minSwap(self, nums1: List[int], nums2: List[int]) -> int:
        n = len(nums1)
        f = [[0, 0] for _ in range(n)]
        for i in range(1, n):
            f[i][0] = f[i][1] = n + 10
        f[0][1] = 1
        for i in range(1, n):
            if nums1[i] > nums1[i - 1] and nums2[i] > nums2[i - 1]:
                f[i][0], f[i][1] = f[i - 1][0], f[i - 1][1] + 1
            if nums1[i] > nums2[i - 1] and nums2[i] > nums1[i - 1]:
                f[i][0], f[i][1] = min(f[i][0], f[i - 1][1]), min(f[i][1], f[i - 1][0] + 1)
        return min(f[n - 1][0], f[n - 1][1])

TypeScript 代码：

function minSwap(nums1: number[], nums2: number[]): number {
    const n = nums1.length
    const f = new Array<Array<number>>(n)
    f[0] = [0, 1]
    for (let i = 1; i < n; i++) f[i] = [n + 10, n + 10]
    for (let i = 1; i < n; i++) {
        if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
            f[i][0] = f[i - 1][0]
            f[i][1] = f[i - 1][1] + 1
        }
        if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
            f[i][0] = Math.min(f[i][0], f[i - 1][1])
            f[i][1] = Math.min(f[i][1], f[i - 1][0] + 1)
        }
    }
    return Math.min(f[n - 1][0], f[n - 1][1])
}

• 时间复杂度：
• 空间复杂度：

滚动数组

利用 仅依赖于 ，我们可以采用「滚动数组」的方式，通过机械性操作将空间优化到 。

Java 代码：

class Solution {
    public int minSwap(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int[][] f = new int[2][2];
        f[0][1] = 1;
        for (int i = 1; i < n; i++) {
            int a = n + 10, b = n + 10;
            int prev = (i - 1) & 1, cur = i & 1; // 避免重复的 & 操作
            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
                a = f[prev][0];
                b = f[prev][1] + 1;
            }
            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
                a = Math.min(a, f[prev][1]);
                b = Math.min(b, f[prev][0] + 1);
            }
            f[cur][0] = a; f[cur][1] = b;
        }
        return Math.min(f[(n - 1) & 1][0], f[(n - 1) & 1][1]);
    }
}

C++ 代码：

class Solution {
public:
    int minSwap(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        vector<vector<int>> f(2, vector<int>(2, 0));
        f[0][1] = 1;
        for (int i = 1; i < n; ++i) {
            int a = n + 10, b = n + 10;
            int prev = (i - 1) & 1, cur = i & 1;
            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
                a = f[prev][0];
                b = f[prev][1] + 1;
            }
            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
                a = min(a, f[prev][1]);
                b = min(b, f[prev][0] + 1);
            }
            f[cur][0] = a;
            f[cur][1] = b;
        }
        return min(f[(n - 1) & 1][0], f[(n - 1) & 1][1]);
    }
};

Python 代码：

class Solution:
    def minSwap(self, nums1: List[int], nums2: List[int]) -> int:
        n = len(nums1)
        f = [[0, 1], [0, 0]]
        for i in range(1, n):
            a, b = n + 10, n + 10
            prev, cur = (i - 1) & 1, i & 1
            if nums1[i] > nums1[i - 1] and nums2[i] > nums2[i - 1]:
                a, b = f[prev][0], f[prev][1] + 1
            if nums1[i] > nums2[i - 1] and nums2[i] > nums1[i - 1]:
                a, b = min(a, f[prev][1]), min(b, f[prev][0] + 1)
            f[cur][0], f[cur][1] = a, b
        return min(f[(n - 1) & 1][0], f[(n - 1) & 1][1])

TypeScript 代码：

function minSwap(nums1: number[], nums2: number[]): number {
    const n = nums1.length
    const f = new Array<Array<number>>(2)
    f[0] = [0, 1], f[1] = [0, 0]
    for (let i = 1; i < n; i++) {
        let a = n + 10, b = n + 10
        const prev = (i - 1) & 1, cur = i & 1
        if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
            a = f[prev][0]
            b = f[prev][1] + 1
        }
        if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
            a = Math.min(a, f[prev][1])
            b = Math.min(b, f[prev][0] + 1)
        }
        f[cur][0] = a; f[cur][1] = b
    }
    return Math.min(f[(n - 1) & 1][0], f[(n - 1) & 1][1])
}

• 时间复杂度：
• 空间复杂度：

最后

给大伙通知一下 📢 ：

全网最低价 LeetCode 会员目前仍可用 ~

📅 年度会员：有效期加赠两个月！！; 季度会员：有效期加赠两周！！

🧧 年度会员：获 66.66 现金红包！！; 季度会员：获 22.22 现金红包！！

🎁 年度会员：参与当月丰厚专属实物抽奖（中奖率 > 30%)！！

专属链接：leetcode.cn/premium/?promoChannel=acoier

我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉