[Leetcode/c++] 第206场周赛

最新推荐文章于 2022-11-27 11:14:12 发布
最新推荐文章于 2022-11-27 11:14:12 发布
阅读量253 收藏 1
点赞数 1
分类专栏： python3 leetcode周赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42227482/article/details/108575302
版权

P1 二进制矩阵中的特殊位置

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

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

暴力

#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define rep(i,a,n) for(int i=a; i<n; i++)
#define per(i,a,n) for(int i=n-1; i>=a; i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define fr(x) freopen(x,"r",stdin)
#define fw(x) freopen(x,"w",stdout)
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<VI> VVI;
typedef vector<VC> VVC;
typedef long long ll;
typedef pair<int, int> PII;
typedef unordered_map<int, int> MII;
typedef double db;
ll gcd(ll a, ll b){return b?gcd(a%b, b):a;}
const ll mod = 1000000007;
// head 
class Solution {
public:
    int numSpecial(vector<vector<int>>& mat) {
        int n = SZ(mat),m = SZ(mat[0]), s;
        VI R, C;
        rep(i, 0, n){
            s = 0;
            rep(j, 0, m) s += mat[i][j];
            if(s == 1) R.pb(i);
        }
        rep(j, 0, m){
            s = 0;
            rep(i, 0, n) s += mat[i][j];
            if(s == 1) C.pb(j);
            
        }
        int ans = 0;
        for(auto i: R) for(auto j: C)
            if(mat[i][j] == 1) ans ++; 
        return ans;

    }
};

P 统计不开心的朋友

给你一份 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
返回 不开心的朋友的数目 。

模拟

#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define rep(i,a,n) for(int i=a; i<n; i++)
#define per(i,a,n) for(int i=n-1; i>=a; i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define fr(x) freopen(x,"r",stdin)
#define fw(x) freopen(x,"w",stdout)
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<VI> VVI;
typedef vector<VC> VVC;
typedef long long ll;
typedef pair<int, int> PII;
typedef unordered_map<int, int> MII;
typedef double db;
ll gcd(ll a, ll b){return b?gcd(a%b, b):a;}
const ll mod = 1000000007;
// head 
class Solution {
public:
    vector<bool> A;
    VVI B;
    int unhappyFriends(int n, vector<vector<int>>& P, vector<vector<int>>& pairs) {
        A.assign(n, true);
        B = P;
        int m = SZ(pairs);
        rep(i, 0, m) rep(j, i+1, m){
            int x = pairs[i][0];
            int y = pairs[i][1];
            int u = pairs[j][0];
            int v = pairs[j][1];
            f(x, y, u, v);
            f(y, x, u, v);
            f(x, y, v, u);
            f(y, x, v, u);
            f(u, v, x, y);
            f(u, v, y, x);
            f(v, u, x, y);
            f(v, u, y, x);
        }
            
        int ans = 0;
        for(auto a:A) if(!a) ans++;
        return ans;
    }
    void f(int x, int y, int u, int v){
       if(closer(x, u, y) && closer(u, x, v)) A[x] = false;
    }
    bool closer(int x, int u, int y){
        for(auto b: B[x]) if(b == u) return true; else if(b == y) return false;
        return false;
    }
};

P 连接所有点的最小费用

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

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

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

并查集(TLE)

感觉没什么道理超时。
在这里插入图片描述

#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define rep(i,a,n) for(int i=a; i<n; i++)
#define per(i,a,n) for(int i=n-1; i>=a; i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define fr(x) freopen(x,"r",stdin)
#define fw(x) freopen(x,"w",stdout)
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<VI> VVI;
typedef vector<VC> VVC;
typedef long long ll;
typedef pair<int, int> PII;
typedef unordered_map<int, int> MII;
typedef double db;
ll gcd(ll a, ll b){return b?gcd(a%b, b):a;}
const ll mod = 1000000007;
// head 
#include <vector>
#include <numeric>

using namespace std;

class UF {
public:
    vector<int> fa;
    vector<int> sz;
    int n;
    int comp_cnt;
    
public:
    UF(int _n): n(_n), comp_cnt(_n), fa(_n), sz(_n, 1) {
        iota(fa.begin(), fa.end(), 0);
    }
    
    int findset(int x) {
        return fa[x] == x ? x : fa[x] = findset(fa[x]);
    }
    
    void unite(int x, int y) {
        if (sz[x] < sz[y]) {
            swap(x, y);
        }
        fa[y] = x;
        sz[x] += sz[y];
        --comp_cnt;
    }
    
    bool findAndUnite(int x, int y) {
        int x0 = findset(x);
        int y0 = findset(y);
        if (x0 != y0) {
            unite(x0, y0);
            return true;
        }
        return false;
    }
};
struct E{int u, v, c;};
class Solution {
public:
    int minCostConnectPoints(vector<vector<int>>& points) {
        int n = SZ(points), t;
        vector<E> e;
        rep(i, 0, n) rep(j, i+1, n){
            t = manhat_dist(points[i], points[j]);
            e.pb(E{i, j, t});
        } 
        sort(all(e), [](E&a, E&b){return a.c < b.c;});
        UF dsu(n);
        int ans = 0;
        for(auto x:e){
            if(dsu.findAndUnite(x.u, x.v)) ans += x.c;
            if(dsu.comp_cnt == 1) break;
        }
        return ans;
        

    }
    int manhat_dist(VI a,VI b){
        int x = abs(a[0] - b[0]);
        int y = abs(a[1] - b[1]);
        return x + y;
    }
};

P4 检查字符串是否可以通过排序子字符串得到另一个字符串

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

选择 s 中一个 非空 子字符串并将它包含的字符就地 升序 排序。
比方说，对下划线所示的子字符串进行操作可以由 “14234” 得到 “12344” 。

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

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

分析

  1. 每次交换操作： 选一个区间，然后排序， 那么得到的序列一直在变小。
  2. 那么是不是可以从高位开始，每一个数字都和target数字对齐， 如果不相等， 就选择最近的数字进行排序。
    e.x 434 -> 344 -> 找到第一个3， 然后做排序。
    那么这样做我们的方法是是固定的， 也就说按照这个策略我们可以模拟得到一个解。
    b{A}a = axxxxx <=> a{sorted([A + b]} = axxxxx
    b{Aa{B}a = axxx <=> aa(sorted([A + B + b)) = axxxx
    看着感觉找两个a，就不太行了， 因为这要求axxx里面第二位也得是a， 而且要保证A和B里面没有比a小的。
    所以， 我们只能找就近的相等数字进行操作。而且， 每次排完A这个序列也排完了不能懂了， 除非后面有更小的要上来。
    再看一下数据范围， 1e5， 字符集大小为10。 不是很大， 大概nlogn。
    先扫一遍， 记录
    A [ 0 ] = i 0 , 0 , i 0 , 1 , i 0 , 2 , . . . i 0 , k A[0] = {i_{0,0}, i_{0,1}, i_{0,2}, ... i_{0,k}} A[0]=i0,0​,i0,1​,i0,2​,...i0,k​
    A [ 9 ] = i 9 , 0 , i 9 , 1 , i 9 , 2 , . . . i 9 , k A[9] = {i_{9,0}, i_{9,1}, i_{9,2}, ... i_{9,k}} A[9]=i9,0​,i9,1​,i9,2​,...i9,k​
    感觉差不多， 如果我们要找的数字在上一位的操作中已经被用掉了， 那么它一定排在另外一个比它小的数字后， 也就是说当前的数字比target要小， 那么久凉了。 反之， 它还在原数组中， 那么，我们可以用预处理得到的个位数字索引。 然后，在设计一个指针指向将要使用下一位元素， 就行了。
    当然，还要考虑相等的情况， 如果相等， 俺么只需要移动该数字的指针指向下一位了。 如果越界了， 说面target中出现的数字比给的那个要多。 比如说 2211 => 1111。返回就好了。 看似很不错， 我们只需要O(n)的时间进行预处理， 然后开始遍历元字符串， 每个字符的操作只是选取一小段子字符串进行排序一定小log(n)。
    恩， 那一定AC了。

以上部分分析存在一个严重的失误点在于我们选取区间后如果直接对该区间进行排序，得到的序列并不是最大的。 就是说它会丢失掉一些可能出现的解。

示例 1：

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

这个示例就说明，我刚才的方法是得不到true的， 因为第一次8和3对比交换排序之后得到的s=“34582”, 已经小于t了。
如果我们选择区间的时候每次选两个，那么s中其他的元素顺序会保持不变。 有了这个醒之后， 代码更简单了。

Hard题的标准可能是需要进行一系列推倒，然后得出一些结论在进行编程。

代码

#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define rep(i,a,n) for(int i=a; i<n; i++)
#define per(i,a,n) for(int i=n-1; i>=a; i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define fr(x) freopen(x,"r",stdin)
#define fw(x) freopen(x,"w",stdout)
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<VI> VVI;
typedef vector<VC> VVC;
typedef long long ll;
typedef pair<int, int> PII;
typedef unordered_map<int, int> MII;
typedef double db;
ll gcd(ll a, ll b){return b?gcd(a%b, b):a;}
const ll mod = 1000000007;
// head 
class Solution {
public:
    bool isTransformable(string s, string t) {
        int n = SZ(s), m = SZ(t), d;
        if(n != m ) return false;
        int pos[10][n];
        rep(i, 0, 10) rep(j, 0, n) pos[i][j] = -1;
        int ptr[10];
        rep(i, 0, 10) ptr[i] = 0;
        rep(i, 0, n) {
            d = s[i] - '0';
            pos[d][ptr[d]] = i; 
            ptr[d]++;
        }
        
        rep(i, 0, 10) ptr[i] = 0;
        int i = 0;
        vector<bool> vis;
        vis.assign(n, false);
        rep(j, 0, n){
            while(vis[i]) i++; 
            if(s[i] == t[j]) {i ++; continue;}
            if(s[i] < t[j]) return false;
            d = t[j] - '0';
            if(pos[d][ptr[d]] == -1) return false;  
            vis[pos[d][ptr[d]]] = true;
            ptr[d] ++;
        }
        return true;
    }
};
lizju
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字典树——例题
mashizuren的博客
11-14 734
给定 n个长度不超过10的数字串，问其中是否存在两个数字串 S、T，使得 S是 T的前缀，多组数据。 输入格式 第一行一个整数 T，表示数据组数。 对于每组数据，第一行一个数n，接下来 n行输入 n个数字串。 输出格式 对于每组数据，若存在两个数字串 S、T，使得 S是 T的前缀，则输出 NO ，否则输出 YES 。 请注意此处结果与输出的对应关系！ 样例 样例输入 2 3 911 97625999 91125426 5 113 12340 123440 12345 98346 样例输出 NO YES 数据
leetcode每日一题—1208.尽可能使字符串相等
jqq125的博客
02-05 150
题目： 给你两个长度相同的字符串，s 和 t。 将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。 用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。 如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。 如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。 思路： 滑动
仅执行一次字符交换能否使两个字符串相等
LTY3301398968的博客
11-27 242
给你长度相等的两个字符串 s1 和 s2 。一次 字符串交换 操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。 如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等，返回 true ；否则，返回 false 。
算法：仅执行一次字符串交换能否是两个字符串相等
weixin_46091073的博客
03-16 698
leetcode 仅执行一次字符串交换能否是两个字符串相等 给你长度相等的两个字符串 s1 和 s2 。一次 字符串交换 操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。 如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等，返回 true ；否则，返回 false 。 代码： bool areAlmostEqual(char * s1, char * s2){ int len = strlen(s1); int count =
字符串对比
u012689941的专栏
03-17 1601
字符串对比 (vip) 问题描述 　　给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一： 　　1：两个字符串长度不等。比如 Beijing 和 Hebei 　　2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing 　　3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能
leetcode走楼梯-LeetCodeCpp:LeetCode/C++/Solution&TestCase
07-01
leetcode走楼梯
leetcode答案-LeetCode:LeetCode/LintCode
06-30
leetcode 答案LeetCode / LintCode(Java) 在 LeetCode 和 LintCode 中记录问题的答案和解释。 如果您遇到有关答案的任何问题并需要进一步解释，请随时与我联系。 + Data Structure + Algorithm 进步 403/573 阵列 94...
leetcode叫数-DataStructure:常见数据结构C++(leetcode/牛客)
06-30
常见数据结构C++解题(leetCode)及随笔练习分析(牛客) 关于LeetCode中的题，Repo中的pdf都有解析。真的非常好的资料，感谢这么多大佬给总结精华新手一定要仔细看呦 链表 最近在看侯捷专家的STL源码分析，恰好有讲到...
Master LeetCode C/C++
09-02
Original Leet Code
leetcode刷题技巧-Leetcode:一些leetcode挑战的Python/C++/Go解决方案
07-06
leetcode 刷题技巧力码解决方案 介绍 在男人的生活中，有这些时刻是您做出承诺的时刻。 5 月 18 日，我承诺在接下来的 11 个月内，我将刷我的技能： Python、Go、C++ 算法 我是一个言出必行的人。 这个存储库是我...
LeetCode 1540. K 次操作转变字符串
error311的博客
08-17 507
题目链接：LeetCode 1540. K 次操作转变字符串 题意： 给你两个字符串s和t，你的目标是在 k次操作以内把字符串s转变成t。 在第 i次操作时（1 <= i <= k），你可以选择进行如下操作： 选择字符串 s中满足 1 <= j <= s.length且之前未被选过的任意下标 j（下标从 1 开始），并将此位置的字符切换 i次。 不进行任何操作。 切换 1 次字符的意思是用字母表中该字母的下一个字母替换它（字母表环状接起来，...
leetcode 5469. K 次操作转变字符串
Qin_酱的博客
08-09 734
5469. K 次操作转变字符串 给你两个字符串 s 和 t ，你的目标是在 k 次操作以内把字符串 s 转变成 t 。 在第 i 次操作时（1 <= i <= k），你可以选择进行如下操作： 选择字符串 s 中满足 1 <= j <= s.length 且之前未被选过的任意下标 j （下标从 1 开始），并将此位置的字符切换 i 次。 不进行任何操作。 切换 1 次字符的意思是用字母表中该字母的下一个字母替换它（字母表环状接起来，所以 ‘z’ 切换后会变成 ‘a’）。 请记住任意一
Trie树
NEFU AB-IN's Blog
08-27 460
Trie + 01Trie
1009: 第六题：字符串操作
weixin_47942875的博客
12-09 1051
题目描述 给定两个字符串s和t，请判断s是否是t的子序列。即从t中删除一些字符，将剩余的字符连接起来，即可获得s。 输入 包括若干个测试数据。每个测试数据由两个ASCII码的数字和字母串s和t组成，s和t的长度不超过10000。输入以EOF结束。 输出 对每个测试数据，如果s是t的子序列则输出“Yes”，否则输出“No” 样例输入 sequence subsequence person compression VERDI vivaVittorioEmanueleReDiItalia 样例输出 Yes No
算法（十一）字符串
更木的博客
02-15 408
算法之字符串
1540 K 次操作转变字符串（字典计数）
二哈
10-07 438
1. 问题描述： 给你两个字符串s和t，你的目标是在 k次操作以内把字符串s转变成t。 在第 i次操作时（1 <= i <= k），你可以选择进行如下操作： 选择字符串 s中满足 1 <= j <= s.length且之前未被选过的任意下标 j（下标从 1 开始），并将此位置的字符切换 i次。 不进行任何操作。 切换 1 次字符的意思是用字母表中该字母的下一个字母替换它（字母表环状接起来，所以 'z'切换后会变成 'a'）。 请记住任意一个下标 j最...
【cf】D. Backspace
qq_64263852的博客
05-30 215
题意： 给出两个字符串s和t，对于s有两种操作，一种是将打印出来，另一种是删除并且不会打印出，问能否通过这两个操作得到t 思路： 首先我们可以考虑t已经从s中得到了，但是s还有部分需要打印，那么这部分长度一定是偶数，因为删除操作实际上是删除两个字符（一个是上一次打印出来的，另一个是当前要打印的），如果这部分长度不是偶数个，那么至少会多出一个字符。同样的，t中相邻的两个字符在s中需要间隔偶数个字符，否则也会至少多出一个字符。考虑贪心，从s的末尾往左找满足条件的字符。因为要找的满足条件的最后一个字符的.
给定两个字符串 S 和 T，求 S 中包含 T 所有字符的最短连续子字符串的长度，同时要求时间复杂度不得超过 O(n)。
小楠的博客
07-26 3218
给定两个字符串 S 和 T，求 S 中包含 T 所有字符的最短连续子字符串的长度，同时要求时间复杂度不得超过 O(n)。
剑指 Offer II 017. 含有所有字符的最短字符串
Tzecto
09-03 477
剑指 Offer II 017. 含有所有字符的最短字符串 给定两个字符串 s 和 t 。返回 s 中包含 t 的所有字符的最短子字符串。如果 s 中不存在符合条件的子字符串，则返回空字符串 “” 。 如果 s 中存在多个符合条件的子字符串，返回任意一个。 注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。 示例 1： 输入：s = "ADOBECODEBANC", t = "ABC" 输出："BANC" 解释：最短子字符串 "BANC" 包含了字符串 t 的所有字
leetcode1109 c++
最新发布
03-26
LeetCode 1109题是关于航班预订统计的问题，可以使用C++语言进行解答。题目要求根据给定的航班预订记录和航班的座位数，计算每个航班的预订座位数。 以下是一种可能的C++解法： ```cpp #include class Solution ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值