力扣刷题ing - 技术栈

1.求出出现两次数字的 XOR 值

太久没刷题了，今天随机的一道题，一个模拟题，慢慢找感觉吧。

c++ 复制代码

class Solution {
public:
    int duplicateNumbersXOR(vector<int>& nums) {
        int len = nums.size();

        map<int, int> mp;
        int flag = 0;
        int ans = 0;
        for (int i = 1; i <= 50; i ++) mp[i] = 0;
        for (int i = 0; i < len; i ++)
        {
            mp[nums[i]] ++;
            if (mp[nums[i]] > 1)
            {
                ans = ans ^ nums[i];
            }
        }

        if (ans)   return ans;
        else    return 0;
    }
};

官方的题解是这样的：因为数据最多就只有50位，那么我们直接用一个50位的二进制来表示就可以了（我是这样理解的），首先，这50位二进制都是0，当x第一次出现是，那么我们就第x位就设置为1，表示出现过，那么在第二次出现的时候，我们通过位运算，将第x位和1进行&运算，判断第x位是否出现过，出现过我们就进行异或，反之就对对应的位置进行设1操作。

c++ 复制代码

long long mask = 0, ans = 0;
for (int t : nums)
{
	if (mask >> t & 1) ans ^= t;
	else mask |= (long long) 1 << t;
}

2. 1884. 鸡蛋掉落-两枚鸡蛋

评论区有朋友说这是个规律题，看样例2就能看出来，但是我感觉太抽象了，根本看不出来。拿到这个题的第一眼，觉得这个题应该是的dp，但是不知道怎么d。首先这里有两个鸡蛋，如果只有1个鸡蛋的话，在n层中，毫无疑问需要n次，但是现在有两个鸡蛋，那么在使用第2个鸡蛋的前提是第一个鸡蛋碎了，那么我们假设dp[k][n]表示有k个鸡蛋，有n层需要的最小操作次数，那么假设将 e 1 e_1 e1扔至第m层，那么这个是有会有两种情况：

如果 e 1 e_1 e1碎了，那么这个时候我们要用 e 2 e_2 e2了，那么此时 e 2 e_2 e2只会在 m − 1 m-1 m−1之间丢了，所以此时的 d p [ 2 ] [ n ] = m i n ( d p [ 2 ] [ n ] , d p [ 1 ] [ m − 1 ] + 1 ) dp[2][n]=min(dp[2][n],dp[1][m-1]+1) dp[2][n]=min(dp[2][n],dp[1][m−1]+1)
如果 e 1 e_1 e1没有碎，那么此时还是有两个蛋，并且我们一定知道 f f f是在 m + 1 − n m+1 - n m+1−n之间的，那么此时其实就是将之前的 1 − n 1-n 1−n转换成了 m + 1 − n m+1-n m+1−n，方法都是一样的了，这个时候 d p [ 2 ] [ n ] = m i n ( d p [ 2 ] [ n ] , d p [ 2 ] [ n − 1 ] + 1 ) dp[2][n]=min(dp[2][n],dp[2][n-1]+1) dp[2][n]=min(dp[2][n],dp[2][n−1]+1)。

c++ 复制代码

class Solution {
public:
    int dp[2][1010];
    int twoEggDrop(int n) {
        
        memset(dp, 0x3f3f3f3f, sizeof(dp));
        // 初始化，当只有一个鸡蛋的时候，无论是多少层，都需要丢n次。
        for (int i = 0; i <= n; i ++) dp[0][i] = i;
        dp[0][0] = dp[1][0] = 0;

        for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= i; j ++)
            dp[1][i] = min(dp[1][i], max(dp[0][j - 1] + 1, dp[1][i - j] + 1));
        // 当我们选定第j层进行实验的时候，无论e_1是否碎了，都需要1次。
        
        return dp[1][n];
    }
};