LeetCode第197场周赛题解

2020.7.12第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

思路

直接枚举所有可能出现的数对，若满足条件则记录。

代码

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

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的最长子串，记录该子串中1的个数，再根据公式计算该子串仅含1的子串数，最后统计总和即可。

代码

class Solution {
public:
    int mod = 1e9 + 7;
    int numSub(string s) {
        int ans = 0, cnt;
        for (int i = 0; i < s.size(); i ++ )
        {
            cnt = 0;
            while (s[i] == '1')
            {
                cnt ++ ;
                i ++ ;
            }
            if (cnt)
            {
                int x = sums(cnt);
                ans = (ans + x) % mod;
            }
        }
        return ans;
    }
    int sums(int n)
    {
        int ans = 0;
        for (int i = 1; i <= n; i ++ ) ans = (ans + i) % mod;
        return ans;
    }
};

1514. 概率最大的路径

题目描述

给你一个由 n 个节点（下标从 0 开始）组成的无向加权图，该图由一个描述边的列表组成，其中 edges[i] = [a, b] 表示连接节点 a 和 b 的一条无向边，且该边遍历成功的概率为 succProb[i] 。
指定两个节点分别作为起点 start 和终点 end ，请你找出从起点到终点成功概率最大的路径，并返回其成功概率。
如果不存在从 start 到 end 的路径，请 返回 0 。只要答案与标准答案的误差不超过 1e-5 ，就会被视作正确答案。
示例 1：

输入：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
示例 2：

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

输入：n = 3, edges = [[0,1]], succProb = [0.5], start = 0, end = 2
输出：0.00000
解释：节点 0 和 节点 2 之间不存在路径
提示：
2 <= n <= 10^4
0 <= start, end < n
start != end
0 <= a, b < n
a != b
0 <= succProb.length == edges.length <= 2*10^4
0 <= succProb[i] <= 1
每两个节点之间最多有一条边

思路

概率最大即为边权的乘积最大
w1 * w2 * … * wn最大
log(w1 * w2 * … * wn)最大
logw1 + logw2 + … + logwn最大
由于0 < w < 1，故logw < 0
-(logw1 + logw2 + … + logwn)最小
此时全为正权边且求最小值，可用dijkstra算法
点数较大，使用堆优化的dijkstra算法
目标是求乘积最大值

代码

class Solution {
public:
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
        typedef pair<int, double> PID;
        typedef pair<double, int> PDI;
        vector<vector<PID>> g(n);
        for (int i = 0; i < edges.size(); i ++ )
        {
            int a, b;
            double c;
            a = edges[i][0], b = edges[i][1];
            c = succProb[i];
            g[a].push_back({b, c});
            g[b].push_back({a, c});
        }
        vector<double> d(n, 0);
        priority_queue<PDI> h; //此时用大根堆，每次取出最大值
        h.push({1.0, start});
        d[start] = 1;
        while (h.size())
        {
            PDI t = h.top();
            h.pop();
            double w = t.first;
            int v = t.second;
            for (int i = 0; i < g[v].size(); i ++)
            {
                PID j = g[v][i];
                if (d[j.first] < w * j.second) //判断时注意变号
                {
                    d[j.first] = w * j.second;
                    h.push({d[j.first], j.first});
                }
            }
        }
        return d[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

思路

计算公式sqrt((x_center - x_i)² + (y_center - y_i)²)
将x固定后，值取决于y，即求一个关于y的二次函数的最小值，求二次函数的最小值可以用三分算法。
先固定x，再固定y，即三分套三分。
关于三分算法的举例：
若为下凸函数（求最小值时）
f(m1) > f(m2)时，最值不会出现在m1左边
情形1：

情形2：

故可以排除m1左端。

代码

class Solution {
public:
    vector<vector<int>> p;

    double f(double x, double y) //根据固定好的x和y通过公式求值
    {
        double sum = 0;
        for (auto &i : p)
        {
            sum += sqrt((i[0] - x) * (i[0] - x) + (i[1] - y) * (i[1] - y));
        }
        return sum;
    }

    double cal(double x) { //固定y（参数为固定好的x）
        double l = 0, r = 100;
        while (r - l > 1e-7)
        {
            double m1 = l + (r - l) / 3, m2 = l + (r - l) / 3 * 2;
            if (f(x, m1) >= f(x, m2)) l = m1;
            else r = m2;
        }
        return f(x, r);
    }

    double getMinDistSum(vector<vector<int>>& positions) { //固定x
        p = positions;
        double l = 0, r = 100;
        while (r - l > 1e-7)
        {
            double m1 = l + (r - l) / 3, m2 = l + (r - l) / 3 * 2;
            if (cal(m1) >= cal(m2)) l = m1;
            else r = m2;
        }
        return cal(r);
    }
};

本文题目来源：力扣（LeetCode）
本文部分思路引自b站大雪菜