LeetCode 第132场周赛

第一次做，很菜，只记录了会的

5024. 除数博弈

爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。

最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作：

• 选出任一 x，满足 0 < x < N 且 N % x == 0 。
• 用 N - x 替换黑板上的数字 N 。

如果玩家无法执行这些操作，就会输掉游戏。

只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 false。假设两个玩家都以最佳状态参与游戏。

示例 1：

输入：2
输出：true
解释：爱丽丝选择 1，鲍勃无法进行操作。

示例 2：

输入：3
输出：false
解释：爱丽丝选择 1，鲍勃也选择 1，然后爱丽丝无法进行操作。

提示：

1. 1 <= N <= 1000

---

可以看出，偶数爱丽丝能赢

class Solution {
public:
    bool divisorGame(int N) {
        if(N&1)
            return false;
        return true;
    }
};

看了前排大佬的dp也是理解了

dp[i]代表N为i时爱丽丝能不能赢，这种题状态都是和前面有关，dp嘛，所以就是枚举i-N的时候，然后判断，每次两个人都是做最优的选择，也就是只要爱丽丝能通过一种方式赢就可以了，判断爱丽丝赢不赢也就是看鲍勃输不输(废话)，判断$dp[i-j],j\in [1,i),imodj==0$

class Solution {
public:
    bool divisorGame(int N) {
        vector<int> dp(N+1,0);
        for(int i=1;i<=N;++i)
            for(int j=1;j<i;++j)
                if(i%j==0) // 或者用第一清华大佬的优秀位运算dp[i]|=!dp[i-j];%%%%%%%%%了
                    if(!dp[i-j]) 
                    {
                        dp[i]=1;
                        break;// 只要有一种可能性能赢就行
                    }
        return dp[N];
    }
};

---

5030. 节点与其祖先之间的最大差值

给定二叉树的根节点 root，找出存在于不同节点 A 和 B 之间的最大值 V，其中 V = |A.val - B.val|，且 A 是 B 的祖先。

（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）

示例：

输入：[8,3,10,1,6,null,14,null,null,4,7,13]
输出：7
解释： 
我们有大量的节点与其祖先的差值，其中一些如下：
|8 - 3| = 5
|3 - 7| = 4
|8 - 1| = 7
|10 - 13| = 3
在所有可能的差值中，最大值 7 由 |8 - 1| = 7 得出。

提示：

1. 树中的节点数在 2 到 5000 之间。
2. 每个节点的值介于 0 到 100000 之间。

---

开始不知道咋做，后来发现就是一个dfs只不过每次只把点的值保留到当前层及以下，如果回溯到父亲节点把其弹出即可

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution
{
  public:
    int ans = 0;
    vector<int> nums;
    void dfs(TreeNode *root)
    {
        if (root == nullptr)
            return;
        for (int num : nums)
            ans = max(ans, abs(root->val - num)); //找最大值
        nums.push_back(root->val);
        dfs(root->left);
        dfs(root->right);
        nums.pop_back(); //需要回溯到父亲层，将其弹出，不能再用
    }

    int maxAncestorDiff(TreeNode *root)
    {
        dfs(root);
        return ans;
    }
};

观摩了一下第一清华大佬的代码，又非常%%%%%%%%%%，确实如上述for循环的功能一样，就是要找最大值和最小值，那么我们可不可以在递归的时候传递这两个值呢，当然可以，而且这两个值在回溯以后会一直保持是当前层及以上的最大最小值，非常方便简洁

class Solution
{
  public:
    int find(TreeNode *root, int maxn, int minn)
    {
        if (root == nullptr)
            return 0;
        int ans = max(maxn - root->val, root->val - minn); //和最大最小值比较
        maxn = max(maxn, root->val);
        minn = min(minn, root->val);
        int l = find(root->left, maxn, minn);  //左
        int r = find(root->right, maxn, minn); //右
        ans = max(ans, max(l, r));
        return ans;
    }
    int maxAncestorDiff(TreeNode *root)
    {
        return find(root, -100000, 100000); //边界值
    }
};