leetCode第197场周赛学习

1512. 好数对的数目

给你一个整数数组 nums 。

如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。

返回好数对的数目。

示例 1：

输入：nums = [1,2,3,1,1,3]
输出：4
解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始
示例 2：

输入：nums = [1,1,1,1]
输出：6
解释：数组中的每组数字都是好数对
示例 3：

输入：nums = [1,2,3]
输出：0

提示：

1 <= nums.length <= 100
1 <= nums[i] <= 100

分析

按照题目意思来 就是对每一个元素 在后面序列中找相同的数 字面意思出发就得到了暴力法的写法

那么怎么优化呢？ 其实继续分析就是一个组合问题，将数组分为若干个相同数字的序列，求序列中取两个元素的组合数，最后将组合数相加就是结果

组合数公式:c*(c-1)/2

暴力法

class Solution {
public:
    int numIdenticalPairs(vector<int>& nums) {
        int res=0;
        for(int i=0;i<nums.size();i++){
            for(int j=i+1;j<nums.size();j++){
                if(nums[i]==nums[j])
                    res++;
            }
        }
        return res;
    }
};

排列组合

class Solution {
public:
    int numIdenticalPairs(vector<int>& nums) {
        int res=0;
        unordered_map<int, int> map;
        for(auto num:nums)
            map[num]++;
        for(auto [a, c]:map){
            res+=c*(c-1)/2;
        }
        return res;
    }
};

1513. 仅含 1 的子串数

给你一个二进制字符串 s（仅由 ‘0’ 和 ‘1’ 组成的字符串）。

返回所有字符都为 1 的子字符串的数目。

由于答案可能很大，请你将它对 10^9 + 7 取模后返回。

示例 1：

输入：s = “0110111”
输出：9
解释：共有 9 个子字符串仅由 ‘1’ 组成
“1” -> 5 次
“11” -> 3 次
“111” -> 1 次
示例 2：

输入：s = “101”
输出：2
解释：子字符串 “1” 在 s 中共出现 2 次
示例 3：

输入：s = “111111”
输出：21
解释：每个子字符串都仅由 ‘1’ 组成
示例 4：

输入：s = “000”
输出：0

提示：

s[i] == ‘0’ 或 s[i] == ‘1’
1 <= s.length <= 10^5

分析

这一题的思路和上一题类似，仅含1的字串 其实就是将数组中按照时候包含’0’分为若干个串 求每个串的真字串

长度为n的串的真字串个数：含1个1的字串 n个，含2个1的字串 n-1个…含n个1的字串 1个,就是n*(n+1)/2

优化了一下避免全局维护 仅局部维护count

模拟

class Solution {
public:
    int numSub(string s) {
        long long mod=1000000007;
        long long count=0;
        long long res=0;
        for(int i=0;i<s.size();i++){
            if(s[i]=='1'){
                count++;
            }else{
            if(count!=0){
                    res+=count*(count+1LL)/2;
                    res%=mod;
                    count=0;
                }
            }
        }
        if(count!=0){
            res+=count*(count+1LL)/2;
            res%=mod;
        }
        return res;
    }
};

优化

class Solution {
public:
    int numSub(string s) {
        int mod=1000000007;
        int res=0;
        for(int i=0;i<s.size();i++){
            if(s[i]!='0'){
                int j=i+1;
                while(s[j]!='0' && j<s.size())
                    j++;
                int count=j-i;
                res=(res+count*(count+1LL)/2)%mod;
                i=j-1;
            }
        }
        return res;
    }
};

1514. 概率最大的路径

给你一个由 n 个节点（下标从 0 开始）组成的无向加权图，该图由一个描述边的列表组成，其中 edges[i] = [a, b] 表示连接节点 a 和 b 的一条无向边，且该边遍历成功的概率为 succProb[i] 。

指定两个节点分别作为起点 start 和终点 end ，请你找出从起点到终点成功概率最大的路径，并返回其成功概率。

如果不存在从 start 到 end 的路径，请 返回 0 。只要答案与标准答案的误差不超过 1e-5 ，就会被视作正确答案。

输入：n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2
输出：0.25000
解释：从起点到终点有两条路径，其中一条的成功概率为 0.2 ，而另一条为 0.5 * 0.5 = 0.25

输入：n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2
输出：0.30000

分析

求概率最大，因为概率是0-1的数，所以其实就是求单源最短路径，用dijkstra算法或者SPFA算法都可

附上之前看到的一篇最短路径的博客 觉得很可

https://blog.csdn.net/qq_44173974/article/details/107613624

dijkstra算法

class Solution {
public:
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
        vector<vector<pair<int,double>>> g(n);
        int m=edges.size();
        //初始化邻接矩阵
        for (int i = 0; i < m; ++i) {
            //边ab 权值c
            int a=edges[i][0];
            int b=edges[i][1];
            double c=succProb[i];
            g[a].push_back({b,c});
            g[b].push_back({a,c});
        }
        //存放结果的 即到i节点的最短路径(本体指的是最大概率)
        vector<double> pro(n,0);
        pro[start]=1.0;
        //使用优先队列优化找队列中最优元素的过程
        priority_queue<pair<double ,int >> heap;
        heap.push({1.0,start});
        while(heap.size()){
            auto top=heap.top();
            heap.pop();
            double p=top.first;
            int node=top.second;
            //因为dijkstra能保证每次都是最优的 所以可以直接返回 而SPFA不行
            if(node==end)
                break;
            for(auto x:g[node]){
                int nn=x.first;
                double pp=x.second;
                if(pp*p>pro[nn]){
                    pro[nn]=pp*p;
                    heap.push({pro[nn],nn});
                }
            }
        }
        return pro[end];
    }
};

SPFA算法

class Solution {
public:
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {

        vector<vector<pair<int, double>>> g(n);
        for (int i = 0; i < edges.size(); i ++ ) {
            //边ab 权值c
            int a = edges[i][0];
            int b = edges[i][1];
            double c=succProb[i];
            g[a].push_back({b,c });
            g[b].push_back({a, c});
        }

        queue<int> qe;
        vector<double> dist(n, 0);
        vector<bool> st(n, false);
        st[start] = true;
        qe.push(start);
        dist[start] = 1;
        while (qe.size()) {
            int top = qe.front();
            qe.pop();
            st[top] = false;
            for (auto x : g[top]) {
                int node = x.first;
                double p = x.second;
                if (dist[node] < p * dist[top]) {
                    dist[node] = p * dist[top];
                    if (!st[node]) {
                        st[node] = true;
                        qe.push(node);
                    }
                }
            }
        }
        return dist[end];
    }
};

1515. 服务中心的最佳位置

一家快递公司希望在新城市建立新的服务中心。公司统计了该城市所有客户在二维地图上的坐标，并希望能够以此为依据为新的服务中心选址：使服务中心 到所有客户的欧几里得距离的总和最小 。

给你一个数组 positions ，其中 positions[i] = [xi, yi] 表示第 i 个客户在二维地图上的位置，返回到所有客户的 欧几里得距离的最小总和 。

换句话说，请你为服务中心选址，该位置的坐标 [xcentre, ycentre] 需要使下面的公式取到最小值：

与真实值误差在 10^-5 之内的答案将被视作正确答案。

示例 1：

输入：positions = [[0,1],[1,0],[1,2],[2,1]]
输出：4.00000
解释：如图所示，你可以选 [xcentre, ycentre] = [1, 1] 作为新中心的位置，这样一来到每个客户的距离就都是 1，所有距离之和为 4 ，这也是可以找到的最小值。
示例 2：

输入：positions = [[1,1],[3,3]]
输出：2.82843
解释：欧几里得距离可能的最小总和为 sqrt(2) + sqrt(2) = 2.82843
示例 3：

输入：positions = [[1,1]]
输出：0.00000
示例 4：

输入：positions = [[1,1],[0,0],[2,0]]
输出：2.73205
解释：乍一看，你可能会将中心定在 [1, 0] 并期待能够得到最小总和，但是如果选址在 [1, 0] 距离总和为 3
如果将位置选在 [1.0, 0.5773502711] ，距离总和将会变为 2.73205
当心精度问题！
示例 5：

输入：positions = [[0,1],[3,2],[4,5],[7,6],[8,9],[11,1],[2,12]]
输出：32.94036
解释：你可以用 [4.3460852395, 4.9813795505] 作为新中心的位置

提示：

1 <= positions.length <= 50
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 100

分析

就是求一个凸函数的极值，由于两个变量，就三分套三分解决，或者梯度下降，模拟退火都可以

三分套三分

class Solution {
public:
    vector<vector<int>> points;
    double get_sum(double x, double y){
        double sum=0;
        for(auto& p:points){
            double a=p[0],b=p[1];
            sum+=sqrt((x-a)*(x-a)+(y-b)*(y-b));
        }
        return sum;
    }
    double calc(double x){
        double l=0,r=100;
        while(r - l > 1e-6){
            double y1=l+(r-l)/3,y2=l+(r-l)/3*2;
            if(get_sum(x,y1)>=get_sum(x,y2))
                l=y1;
            else
                r=y2;
        }
        return get_sum(x,r);
    }
    double getMinDistSum(vector<vector<int>>& positions) {
        points=positions;
        double l=0,r=100;
        while(r - l > 1e-6){
            double x1=l+(r-l)/3,x2=l+(r-l)/3*2;
            if(calc(x1)>=calc(x2))
                l=x1;
            else
                r=x2;
        }
        return calc(r);
    }
};