力扣第157场双周赛

关注

原创 2025-05-28 16:38:51 1.3k 阅读 AI 写同款· GEO 优化 ›

别再只跑recon-all了！FreeSurfer实战：从T1图像到freeview可视化的完整避坑指南本文详细解析FreeSurfer从T1图像处理到freeview可视化的全流程，包括环境配置、recon-all深度解析、高级可视化技巧及性能优化策略。特别针对常见错误提供解决方案，帮助用户高效完成MRI数据分析，避免常见陷阱。阅读详情

1. 最大质数子字符串之和

给定一个字符串 s，找出可以由其子字符串组成的 3个最大的不同质数的和。

返回这些质数的总和，如果少于 3 个不同的质数，则返回所有不同质数的和。

质数是大于 1 且只有两个因数的自然数：1和它本身。

子字符串是字符串中的一个连续字符序列。

注意：每个质数即使出现在多个子字符串中，也只能计算一次。此外，将子字符串转换为整数时，忽略任何前导零。

示例 1：

输入： s = "12234"

输出： 1469

解释：

由 "12234" 的子字符串形成的不同质数为 2 ，3 ，23 ，223 和 1223。
最大的 3 个质数是 1223、223 和 23。它们的和是 1469。
示例 2：

输入： s = "111"

输出： 11

解释：

由 "111" 的子字符串形成的不同质数是 11。
由于只有一个质数，所以结果是 11。

提示：

1 <= s.length <= 10
s 仅由数字组成。

解题思路：字符串的长度只有10，注意字符串转 int -> [-10^9,10^9]时会超, 其他就是简单模拟即可

class Solution {
public:
    bool solve(long long num){
        if(num<2) return false;
        for(long long i=2;i*i<=num;i++){
            if(num%i==0) return false;
        }
        return true;
    }
    long long sumOfLargestPrimes(string s) {
        set<long long> a;
        int n=s.size();
        for(int i=0;i<n;i++){
            string tmp="";
            for(int j=i;j<n;j++){
                tmp+=s[j];         
                long long v=stoll(tmp);
                if(solve(v)){
                    a.insert(v);
                }
            }
        }
        vector<long long> b(a.begin(),a.end()); sort(b.begin(),b.end()); int n_b=b.size(); long long sum=0;
        if(n_b>=3) return b[n_b-1]+b[n_b-2]+b[n_b-3];
        else{
            sum=accumulate(b.begin(),b.end(),0LL);
        }
        return sum;
    }
};

2. 不相交子字符串的最大数量

给你一个字符串 word。

返回以首尾字母相同且长度至少为 4 的不相交子字符串的最大数量。

子字符串是字符串中连续的非空字符序列。

示例 1：

输入： word = "abcdeafdef"

输出： 2

解释：

两个子字符串是 "abcdea" 和 "fdef"。

示例 2：

输入： word = "bcdaaaab"

输出： 1

解释：

唯一的子字符串是 "aaaa"。注意我们不能同时选择 "bcdaaaab"，因为它和另一个子字符串有重叠。

提示：

1 <= word.length <= 2 * 10^5
word 仅由小写英文字母组成。

解题思路：

f[i]=max(f[i-1],f[j-1]+1)
f(i): 从前i个字符中最多能选出多少个符合条件的子串

class Solution {
public:
    int maxSubstrings(string word) {
        int n=word.size();
        vector<int> pre(26),a(n+1);
        for(int i=1;i<=n;i++){
            a[i]=pre[word[i-1]-'a'];
            pre[word[i-1]-'a']=i;
        }
        vector<int> f(n+1);
        f[0]=0;
        for(int i=1;i<=n;i++){
            f[i]=f[i-1];
            int j=a[i];
            while(j>0&&i-j<3) j=a[j];
            if(j>0){
                f[i]=max(f[i],f[j-1]+1);
            }
        }
        return f[n];
    }
};

3. 给边赋权值的方案数 I

给你一棵 n 个节点的无向树，节点从 1 到 n 编号，树以节点 1 为根。树由一个长度为 n - 1 的二维整数数组 edges 表示，其中 edges[i] = [ui, vi] 表示在节点 ui 和 vi 之间有一条边。
一开始，所有边的权重为 0。你可以将每条边的权重设为 1 或 2。

两个节点 u 和 v 之间路径的代价是连接它们路径上所有边的权重之和。

选择任意一个深度最大的节点 x。返回从节点 1 到 x 的路径中，边权重之和为奇数的赋值方式数量。

由于答案可能很大，返回它对 10^9 + 7 取模的结果。

注意：忽略从节点 1 到节点 x 的路径外的所有边。

解题思路：每条边的边权只能是1或者2，保证边上的边权和是奇数，保证有奇数个1即可，

实现上我们先求出最大深度x, 然后从x条边种选出1,3,5个1，其他为2

然后我们套用组合数公式Cn1+Cn3+...=2^(n-1)

class Solution {
public:
    int mx=0;
    const int M=1e9+7; vector<vector<int>> g; 
    void dfs(int i, int fa , int d){
        for(int x: g[i]){
            if(x!=fa){
                dfs(x,i,d+1);
            }
        }  
        mx=max(mx,d);
    }
    int assignEdgeWeights(vector<vector<int>>& edges){
        int n=edges.size()+1;
        g.resize(n+1);
        for(int i=0;i<n-1;i++){
            int x=edges[i][0],y=edges[i][1];
            g[x].push_back(y); g[y].push_back(x);
        }
        vector<int> p(n+1);
        p[0]=1;
        for(int i=1;i<=n;i++) p[i]=p[i-1]*2%M;
        dfs(1,0,0);
        return p[mx-1];
    }
};

4. 给边赋权值的方案数 II

给你一棵有 n 个节点的无向树，节点从 1 到 n 编号，树以节点 1 为根。树由一个长度为 n - 1 的二维整数数组 edges 表示，其中 edges[i] = [ui, vi] 表示在节点 ui 和 vi 之间有一条边。

一开始，所有边的权重为 0。你可以将每条边的权重设为 1 或 2。

两个节点 u 和 v 之间路径的代价是连接它们路径上所有边的权重之和。

给定一个二维整数数组 queries。对于每个 queries[i] = [ui, vi]，计算从节点 ui 到 vi 的路径中，使得路径代价为奇数的权重分配方式数量。

返回一个数组 answer，其中 answer[i] 表示第 i 个查询的合法赋值方式数量。

由于答案可能很大，请对每个 answer[i] 取模 10^9 + 7。

注意：对于每个查询，仅考虑 ui 到 vi 路径上的边，忽略其他边。

解题思路：相比上题多了一个query的操作，变成ui -> vi 的路径权重和为奇数的方案数, 和上场周赛最后一题(可以直接点开我主页力扣栏查看即可), 类似,

注：到底是比赛谁套个板子, 还有脸发到某站当比赛实录啊

const int M=1e9+7;
class LCA_solve {
public:
    vector<int> depth, to_root_minD;
    vector<vector<int>> pa;
    LCA_solve(vector<vector<int>>& edges) {
        int n = edges.size() + 1;
        int m = bit_width(edges.size() + 1); 
        vector<vector<int>> g(n);
        for (auto& e : edges) {
            int x = e[0]-1, y = e[1]-1;
            g[x].push_back(y);
            g[y].push_back(x);
        }
        depth.resize(n);
        pa.resize(n, vector<int>(m, -1));
        auto dfs = [&](this auto&& dfs, int x, int fa) -> void {
            pa[x][0] = fa;
            for (auto& y : g[x]) {
                if (y != fa) {
                    depth[y] = depth[x] + 1;
                    dfs(y, x);
                }
            }
        };
        dfs(0, -1);
        for (int i = 0; i < m - 1; i++) {
            for (int x = 0; x < n; x++) {
                if (int p = pa[x][i]; p != -1) {
                    pa[x][i + 1] = pa[p][i];
                }
            }
        }
    }
    int get_kth_ancestor(int node, int k) {
        for (; k; k &= k - 1) {
            node = pa[node][countr_zero((unsigned)k)];
        }
        return node;
    }
    int get_lca(int x, int y) {
        if (depth[x] > depth[y]) {
            swap(x, y);
        }
        y = get_kth_ancestor(y, depth[y] - depth[x]);
        if (y == x) {
            return x;
        }
        for (int i = pa[x].size() - 1; i >= 0; i--) {
            int px = pa[x][i], py = pa[y][i];
            if (px != py) {
                x = px;
                y = py;
            }
        }
        return pa[x][0];
    }
    int twoPoits_dis(int x, int y) {
        return depth[x] + depth[y] - depth[get_lca(x, y)] * 2;
    }
};
class Solution {
public:
    vector<int> assignEdgeWeights(vector<vector<int>>& edges, vector<vector<int>>& queries) {
        int n=edges.size(); 
        vector<int> p(n+1);
        p[0]=1;
        for(int i=1;i<=n;i++) p[i]=p[i-1]*2%M;
        LCA_solve g(edges);
        vector<int> ans(queries.size());
        for (int i=0;i<queries.size();i++) {
            int x=queries[i][0]-1;
            int y=queries[i][1]-1;
            if (x!=y){
                ans[i]=p[g.twoPoits_dis(x, y) - 1];
            }
        }
        return ans;
    }
};