Devin的LC,CF题解

---

前言

从今天开始发布自己的LeetCode, CodeForces题解。算是践行一下费曼学习法，如果能够给你提供到帮助那自然是更好了。

---

一、LeetCode每日一题

题目链接

石子游戏

题解

提示：个人习惯把思考过程都写出来，可以跳着看。

观察数据范围 $2<=piles.length<=500$,提示我们可以设计$O(N^2)或O(N^{2}logN)$的算法。

• 错误解法：
  • 考虑贪心的去取，每个人每次取出左右端可取的最大值。使用一对对撞指针去维护左右可取的端点即可。
  • 观察如下例子：[1,1,10,2]，设a是亚历克斯的得分，b是李的得分。
  • 开始模拟每一轮
    • a = 2, b = 0
    • a = 2, b = 10
    • a = 3, b = 10
    • a = 3, b = 11
  • 而这样选显然不是最优的，也就是说我们的贪心策略是错误的。
• 正确解法：
  • 如果我们能够解决一个小的区间的问题，那么我们怎样利用这个小区间的答案去递推出大区间的答案呢？
  • 设$dp[i,j]$表示$[i,j]$这个区间先手能够获得的最大分数。
  • 设$sum[i,j]$表示$[i,j]$这个区间对应元素的和。
  • 那么$dp[i,j]$可以由两部分构成。
    • 考虑取走左端点，也就是$piles[i]$，那么我们能取得的最大结果就是$sum[i+1,j]-dp[i+1,j]+piles[i]$，因为取走$i$后轮到对方变成先手，而他能在$[i+1,j]$区间取得的最大结果就是$dp[i+1,j]$,而剩下的就是我们能取到的即(用总的-别人能取到的)。
    • 取走右端点同理,结果为$sum[i,j-1]-dp[i,j-1]+piles[j]$
    • 该区间的答案就是取左与取右中的更大者。
  • 那么$dp[i,j]=max(sum[i+1,j]-dp[i+1,j]+piles[i],sum[i,j-1]-dp[i,j-1]+piles[j])$
  • 只要最后先手在区间$[1,piles.length]$中获得的最大分数>总分数的一半，他就赢了。

vector<int> pref;

int sum(int i, int j) {
    return pref[j] - pref[i - 1];
}

bool stoneGame(vector<int>& piles) {
    int n = piles.size();
    pref.resize(n + 1);
    for (int i = 1; i <= n; i++) pref[i] = pref[i - 1] + pref[i - 1];

    vector<vector<int>> dp(n + 1, vector<int>(n + 1));
    // 子区间长度为1的情况
    for (int i = 1; i <= n; ++i) dp[i][i] = piles[i - 1];
    // 枚举子区间长度p
    for (int p = 2; p <= n; ++p) {
        // 只要[i,j]区间没超过范围就继续循环
        for (int i = 1, j = i + p - 1; j <= n; ++i, ++j) {
            dp[i][j] = max(sum(i + 1, j) - dp[i + 1][j] + piles[i - 1],
                           sum(i, j - 1) - dp[i][j - 1] + piles[j - 1]);
        }
    }
    return dp[1][n] > sum(1, n) / 2;
}

时空复杂度分析

• 求前缀和时间复杂度$O(n)$，空间复杂度$O(n)$
• 我们枚举了$1到n$所有长度的子区间并求解$dp$数组，时间复杂度$O(n^2)$,空间复杂度$O(n^2)$
• 总时间复杂度$O(n^2)$，空间复杂度$O(n^2)$

二、CodeForces题解

1.Perfectly Imperfect Array

题目

Perfectly Imperfect Array

题目大意

给你$n$个数字，判断是否存在一个子序列，使得这个子序列的乘积不是完全平方数。存在输出YES,否则输出NO。

• 子序列：从这$n$个数中随便删掉一些数字剩下的数(保持顺序不变)
• 完全平方数：能够写成$a\ast a$这种形式的数字,例如：$9=3\ast 3$

题解

观察数据范围$1<=n<=100$ 提示我们可以设计一个最坏是$O(n^3)$的算法。

• 什么情况下一定存在完全平方数？
• 答：当给你的$n$个数都是完全平方数的时候。考虑两个数$a,b$若他们均为完全平方数，则$a=x\ast x,b=y\ast y$所以$a\ast b=x\ast x\ast y\ast y=(x\ast y)\ast (x\ast y)$也是完全平方数。多个数字的情况可用数学归纳法严格证明。
• 所以想到一个解法，验证每个数字是否为完全平方数若是，则一定没有办法，输出NO。否则只要选择那个非完全平方数的数字作为子序列即可。

#include <bits/stdc++.h>
using namespace std;

void solve() {
    int n;
    cin >> n;
    bool good = false;
    for (int i = 0, v; i < n; ++i) {
        scanf("%d", &v);
        int k = (int)sqrt(v);
        if (k * k != v) good = true;
    }
    if (good) cout << "YES\n";
    else cout << "NO\n";
}

int main() {
    int t;
    cin >> t;
    while (t--) solve();
    return 0;
}

时空复杂度分析

• 循环$n$次，内置求平方根函数可看作$O(1)$ ,所以总时间复杂度$O(n)$
• 只用了常数个变量，总空间复杂度$O(1)$

2.AND 0, Sum Big

题目

AND 0, Sum Big

题目大意

给你一个$n$和一个$k$，任意选择$n$个$[0,2^k)$这个区间中的数字，每个数字可选任意次，使得所有数字的和最大并且按位与的结果为0的方案数，由于结果很大所以要取余$10^9+7$。

题解

观察数据范围$1<=n<=10^5,1<=k<=20$ 提示我们可以设计一个最坏是$O(nlogn)$的算法。

• 首先我们可以直接找到满足条件的最大和，按照第一个数字取0其余全部取最大值即可，也就是$(n-1)\ast (2^k-1)$。
• 考虑完全背包，发现数字范围大的可怕。所以考虑组合数学的方法。
• 我们按比特位去考虑，要想让这一位做与的结果为0，在这$n$个数字中至少需要一个数字的该位为0。然而我们又想让总和最大，所以贪心的去考虑，其他数字的该位必然为1，也就是$n$个数字中至多需要一个数字的该位为0。这也就证明了,每一位恰好只有一个0。
• 横轴代表这$n$个数字,纵轴$k$代表每一位，以第一位举例，第一位取0的可能有$n$种,这$k$位都是如此,所以答案就是$n^k$

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
 
 // 快速幂O(logn),求a^n
int fastPow(ll a, int n) {
    ll ans = 1;
    while (n > 0) {
        if (n & 1) ans = (ans * a) % mod;
        a = (a * a) % mod;
        n >>= 1;
    }
    return (int) ans;
}
 
void solve() {
    int n, k; cin >> n >> k;
    cout << fastPow(n, k) << endl;
}
 
int main() {
    int t;
    cin >> t;
    while (t--) solve();
    return 0;
}

时空复杂度分析

• 总复杂度取决于快速幂函数$O(logk)$
• 只用了常数个变量，总空间复杂度$O(1)$

3.Product 1 Modulo N

题目

Product 1 Modulo N

题目大意

给你一个整数$n$选择$[1,n)$中尽可能长的一个子序列使得他们的乘积对$n$取余为$1$

题解

观察数据范围$2<=n<=10^5$ 提示我们可以设计一个最坏是$O(nlogn)$的算法。

• 首先从题目出发。设乘积为$p$, 乘积对$n$取余为$1$代表$p=c\ast n+1$。
• 思考什么时候$p$对$n$取余不为$1$?
  • 答：当存在一个数$k$不与$n$互质,而且它贡献给了乘积$p,即p=c_1\ast k$
  • 因为$k$与$n$不互质时则存在$d>1$,使得$d|k$且$d|n$,即$k=c_2\ast d,n=c_3\ast d$
  • 假设$p$包含$k$
  • $p=c\ast n+1=c\ast (c_3\ast d)+1$
  • 又因为$p=c_1\ast k=c_1\ast c_2\ast d$
  • 所以$c_1\ast c_2\ast d=c\ast c_3\ast d+1$,由于整数的离散性，这个式子当且仅当$d=1$时成立。
  • 而与我们假设的$d>1$矛盾，所以我们的$p$中不应该包含不与$n$互质的$k$
• 这样我们也就想到了一个解法枚举$[1,n)$中所有与$n$互质的数，并把他们作为$p$的一部分。
  • 若最后的结果取余$n$等于1，则直接输出。
  • 否则，让该结果除掉$p$即可。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
void solve() {
    int n; cin >> n;
    vector<int> cop;
    ll p = 1;
    for (int i = 1; i < n; ++i) {
        if (__gcd(i, n) == 1) {
            cop.push_back(i);
            p = (p * i) % n;
        }
    }
    
    if (p != 1) {
        cout << cop.size() - 1 << endl;
        for (int v : cop) {
            if (v == 0) break;
            if (v == p) continue;
            printf("%d ", v);
        }
    } else {
        cout << cop.size() << endl;
        for (int v : cop) {
            if (v == 0) break;
            printf("%d ", v);
        }
    }
    cout << endl;
}
 
int main() {
    solve();
    return 0;
}

时空复杂度分析

• 循环$n$次，内置求最大公约数的函数可看作$O(logn)$ ,还有$O(n)$的输出结果,所以总时间复杂度$O(nlogn)$
• 存储要输出的数字，总空间复杂度$O(n)$