LeetCode 第 206 场周赛(733/4491,前16.3%)

1. 比赛结果

做出来3题。继续加油!

全国排名: 733 / 4491,16.3%;全球排名: 2140 / 13291,16.1%

2. 题目

1. LeetCode 5511. 二进制矩阵中的特殊位置 easy

题目链接

给你一个大小为 rows x cols 的矩阵 mat,其中 mat[i][j] 是 0 或 1,请返回 矩阵 mat 中特殊位置的数目 。

特殊位置 定义:如果 mat[i][j] == 1 并且第 i 行和第 j 列中的所有其他元素均为 0(行和列的下标均 从 0 开始 ),则位置 (i, j) 被称为特殊位置。

示例 1:
输入:mat = [[1,0,0],
            [0,0,1],
            [1,0,0]]
输出:1
解释:(1,2) 是一个特殊位置,
因为 mat[1][2] == 1 且所处的行和列上所有其他元素都是 0

示例 2:
输入:mat = [[1,0,0],
            [0,1,0],
            [0,0,1]]
输出:3
解释:(0,0), (1,1)(2,2) 都是特殊位置

示例 3:
输入:mat = [[0,0,0,1],
            [1,0,0,0],
            [0,1,1,0],
            [0,0,0,0]]
输出:2

示例 4:
输入:mat = [[0,0,0,0,0],
            [1,0,0,0,0],
            [0,1,0,0,0],
            [0,0,1,0,0],
            [0,0,0,1,1]]
输出:3
 
提示:
rows == mat.length
cols == mat[i].length
1 <= rows, cols <= 100
mat[i][j]01

解题:

  • 先计算出每行,每列 1的个数
  • 再次遍历矩阵,数字为1,且行列1的个数均为1
class Solution {
    
public:
    int numSpecial(vector<vector<int>>& mat) {
    
        int m = mat.size(), n = mat[0].size();
        int c = 0, i, j;
        vector<int> ct1(m, 0), ct2(n,0);
        for(i = 0; i < m; ++i)
        {
    
        	c = 0;
        	for(j =0 ; j < n; ++j)
        	{
    
        		if(mat[i][j]==1)
        			c++;
        	}
        	ct1[i] = c;
        }
        for(j = 0; j < n; ++j)
        {
    
        	c = 0;
        	for(i =0 ; i < m; ++i)
        	{
    
        		if(mat[i][j]==1)
        			c++;
        	}
        	ct2[j] = c;
        }
        c = 0;
        for(int i = 0; i < m; ++i)
        {
    
            if(ct1[i] != 1)
                continue;
        	for(int j =0 ; j < n; ++j)
        	{
    
        		if(mat[i][j] && ct2[j]==1)
        			c++;
        	}
        }
        return c;
    }
};

48 ms 13.1 MB

2. LeetCode 5512. 统计不开心的朋友 medium

题目链接

给你一份 n 位朋友的亲近程度列表,其中 n 总是 偶数

对每位朋友 i,preferences[i] 包含一份 按亲近程度从高到低排列 的朋友列表。
换句话说,排在列表前面的朋友与 i 的亲近程度比排在列表后面的朋友更高。
每个列表中的朋友均以 0 到 n-1 之间的整数表示。

所有的朋友被分成几对,配对情况以列表 pairs 给出,其中 pairs[i] = [xi, yi] 表示 xi 与 yi 配对,且 yi 与 xi 配对。

但是,这样的配对情况可能会是其中部分朋友感到不开心。
x 与 y 配对u 与 v 配对的情况下,如果同时满足下述两个条件,x 就会不开心

  • x 与 u 的亲近程度胜过 x 与 y,且
  • u 与 x 的亲近程度胜过 u 与 v

返回 不开心的朋友的数目 。

示例 1:
输入:n = 4, 
preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], 
pairs = [[0, 1], [2, 3]]
输出:2
解释:
朋友 1 不开心,因为:
- 10 配对,但 13 的亲近程度比 10 高,且
- 31 的亲近程度比 32 高。
朋友 3 不开心,因为:
- 32 配对,但 31 的亲近程度比 32 高,且
- 13 的亲近程度比 10 高。
朋友 02 都是开心的。

示例 2:
输入:n = 2, preferences = [[1], [0]], pairs = [[1, 0]]
输出:0
解释:朋友 01 都开心。

示例 3:
输入:n = 4, 
preferences = [[1, 3, 2], [2, 3, 0], [1, 3, 0], [0, 2, 1]], 
pairs = [[1, 3], [0, 2]]
输出:4
提示:
2 <= n <= 500
n 是偶数
preferences.length == n
preferences[i].length == n - 1
0 <= preferences[i][j] <= n - 1
preferences[i] 不包含 i
preferences[i] 中的所有值都是独一无二的
pairs.length == n/2
pairs[i].length == 2
xi != yi
0 <= xi, yi <= n - 1
每位朋友都 恰好 被包含在一对中

解题:

  • 先预处理出,每个人的列表里的关系值大小 rela
  • 然后按题意模拟
class Solution {
    
public:
    int unhappyFriends(int n, vector<vector<int>>& preferences, vector<vector<int>>& pairs) {
    
        vector<vector<int>> g(n);
        for(auto& p : pairs)// pair 转化为无向图
        {
    
            g[p[0]].push_back(p[1]);
            g[p[1]].push_back(p[0]);
        }
        vector<vector<int>> rela(n,vector<int>(n, 0));//关系数值
        for(int i = 0, val; i < n; i++)
        {
    
            val = n;
            for(int id : preferences[i])
                rela[i][id] = val--;//关系值递减
        }

        int x,y,u,v,i;
        vector<int> unhappy(n, 0);
        for(x = 0, y; x < n; x++)//遍历每个人
        {
    
            y = g[x][0], u, v;
            for(i = 0; i < n-1; i++)
            {
    
                if(preferences[x][i] == y)
                    break;
                u = preferences[x][i];//y前面的人(条件1)
                v = g[u][0];// u , v 配对的人
                if(rela[u][x] > rela[u][v])//(条件2)
                    unhappy[x] = 1;
            }
        }
        return accumulate(unhappy.begin(), unhappy.end(),0);
    }
};

144 ms 26.2 MB

3. LeetCode 5513. 连接所有点的最小费用 medium

题目链接

给你一个points 数组,表示 2D 平面上的一些点,其中 points[i] = [xi, yi]

连接点 [xi, yi] 和点 [xj, yj] 的费用为它们之间的 曼哈顿距离 :|xi - xj| + |yi - yj| ,其中 |val| 表示 val 的绝对值。

请你返回将所有点连接的最小总费用
只有任意两点之间 有且仅有 一条简单路径时,才认为所有点都已连接。

示例 1:

这里是引用

这里是引用

输入:points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
输出:20
解释:
我们可以按照上图所示连接所有点得到最小总费用,总费用为 20 。
注意到任意两个点之间只有唯一一条路径互相到达。
示例 2:
输入:points = [[3,12],[-2,5],[-4,1]]
输出:18

示例 3:
输入:points = [[0,0],[1,1],[1,0],[-1,1]]
输出:4

示例 4:
输入:points = [[-1000000,-1000000],[1000000,1000000]]
输出:4000000

示例 5:
输入:points = [[0,0]]
输出:0
 
提示:
1 <= points.length <= 1000
-106 <= xi, yi <= 106
所有点 (xi, yi) 两两不同。

解题:

prim算法:vis标记点,把该点相连的边全部加入优先队列,取出最小的边,边的另一端点的所有边加入队列

struct cmp
{
    
    bool operator()(const pair<int,int>& a, const pair<int,int>& b) const
    {
    
        return a.second > b.second;//小顶堆, 距离小的优先
    }
};
class Solution {
    
public:
    int minCostConnectPoints(vector<vector<int>>& points) {
    
        int n = points.size();
        if(n == 1) return 0;
        vector<bool> vis(n, false);
        vector<vector<pair<int,int>>> edges(n,vector<pair<int,int>>());
        for(int i = 0, j, d; i < n; i++)
        {
    
            for(j = i+1; j < n; j++)
            {
    
                
                d = abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1]);
                edges[i].push_back({
    j,d});
                edges[j].push_back({
    i,d});
            }
        }
        priority_queue<pair<int,int>, vector<pair<int,int>>, cmp> q;
        int to, distance, total = 0, edge_num = 0;
        vis[0] = true;
        for(auto& e : edges[0])
            q.push(e);  
        while(!q.empty())
        {
    
            to = q.top().first;
            distance = q.top().second;
            q.pop();
            if(!vis[to])
            {
    
                vis[to] = true;
                total += distance;
                edge_num++;
                if(edge_num == n-1)
                    return total;
                for(auto& e : edges[to])
                    q.push(e);           
            }
        }
        return -1;
    }
};

1288 ms 162.2 MB

kruskal 算法:对所有的边排序,短的优先,用并查集检查边的两个端点是否属于一个集合(不属于的话,加入边,合并两个端点)

class dsu{
    
public:
	vector<int> f;
	dsu(int n)
	{
    
		f.resize(n);
		for (int i = 0; i < n; ++i)
			f[i] = i;
	}
	void merge(int a, int b)
	{
    
		int fa = find(a), fb = find(b);
		f[fa] = fb;
	}
	int find(int a)
	{
    
		if(a == f[a])
			return a;
		return f[a] = find(f[a]);
	}
};
struct edge{
    
    int d;
    int p1, p2;
    edge(int dis, int a, int b)
    {
    
        d = dis, p1 = a, p2 = b;
    }
};
class Solution {
    
public:
    int minCostConnectPoints(vector<vector<int>>& points) {
    
    	int n = points.size();
    	if(n == 1) return 0;
    	dsu u(n);
    	vector<edge> e(n*(n-1)/2, edge(0,0,0));
    	for(int i = 0, k = 0, j, d; i < n; i++)
    	{
    
    		for(j = i+1; j < n; j++)
    		{
    
    			d = abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1]);
    			e[k++] = edge(d,i,j);
    		}
    	}
    	sort(e.begin(), e.end(),[&](auto& a, auto& b){
    
    			return a.d < b.d;
    		});
    	int N = n-1, p1, p2, d, ans = 0, f1, f2;
    	for(int i = 0; i < e.size(); ++i)
    	{
    
            p1 = e[i].p1, p2 = e[i].p2;
            d = e[i].d;
            f1 = u.find(p1), f2 = u.find(p2);
    		if(f1 == f2)
    			continue;
    		ans += d;
            u.f[f1] = f2;
    		if(--N == 0)
    			break;
    	}
    	return ans;
    }
};

1184 ms 31.6 MB

4. LeetCode 5514. 检查字符串是否可以通过排序子字符串得到另一个字符串 hard

题目链接

给你两个字符串 s 和 t ,请你通过若干次以下操作将字符串 s 转化成字符串 t :

  • 选择 s 中一个 非空 子字符串并将它包含的字符就地 升序 排序。

比方说,对下划线所示的子字符串进行操作可以由 “1423 4” 得到 “12344” 。

如果可以将字符串 s 变成 t ,返回 true 。否则,返回 false 。

一个 子字符串 定义为一个字符串中连续的若干字符。

示例 1:
输入:s = "84532", t = "34852"
输出:true
解释:你可以按以下操作将 s 转变为 t :
"84532" (从下标 2 到下标 3-> "84352"
"84352" (从下标 0 到下标 2-> "34852"

示例 2:
输入:s = "34521", t = "23415"
输出:true
解释:你可以按以下操作将 s 转变为 t :
"34521" -> "23451"
"23451" -> "23415"

示例 3:
输入:s = "12345", t = "12435"
输出:false

示例 4:
输入:s = "1", t = "2"
输出:false
 
提示:
s.length == t.length
1 <= s.length <= 105
s 和 t 都只包含数字字符,即 '0''9'

解题:

参考zerotrac2 大佬的题解

class Solution {
    
public:
    bool isTransformable(string s, string t) {
    
    	int n = s.size();
    	vector<queue<int>> pos(10);
    	for(int i = 0; i < n; ++i) 
    		pos[s[i]-'0'].push(i);
    	for(int i = 0; i < n; ++i)
    	{
    
    		if(pos[t[i]-'0'].empty())
    			return false;//字符内容对不上
    		for(int d = 0; d < t[i]-'0'; ++d)
    		{
    
    			if(!pos[d].empty() && pos[d].front() < pos[t[i]-'0'].front())
    				//前面有数字比我小的,升序不可能做到
    				return false;
    		}
            pos[t[i]-'0'].pop();
    	}
    	return true;
    }
};

168 ms 16.9 MB


我的CSDN博客地址 https://michael.blog.csdn.net/

长按或扫码关注我的公众号(Michael阿明),一起加油、一起学习进步!
Michael阿明

猜你喜欢

转载自blog.csdn.net/qq_21201267/article/details/108561122
今日推荐