leetcode205周赛

周赛链接:https://leetcode-cn.com/contest/weekly-contest-205/

T1.替换所有的问号
给你一个仅包含小写英文字母和 ‘?’ 字符的字符串 s ,请你将所有的 ‘?’ 转换为若干小写字母,使最终的字符串不包含任何 连续重复 的字符。

注意:你 不能 修改非 ‘?’ 字符。

题目测试用例保证 除 ‘?’ 字符 之外,不存在连续重复的字符。

在完成所有转换(可能无需转换)后返回最终的字符串。如果有多个解决方案,请返回其中任何一个。可以证明,在给定的约束条件下,答案总是存在的。

示例 1:

输入:s = “?zs”
输出:“azs”
解释:该示例共有 25 种解决方案,从 “azs” 到 “yzs” 都是符合题目要求的。只有 “z” 是无效的修改,因为字符串 “zzs” 中有连续重复的两个 ‘z’ 。

提示:

1 <= s.length <= 100

s 仅包含小写英文字母和 ‘?’ 字符

分析:相邻的字符不同,相邻字符包括左右两边,那么当前字符选择的限制,就来自左边两边的字符,那就简单了,我们只需要选择一个 既不和左边又不和右边相等的小写字母。
思路:如何进行选择呢?
1.首先我们处理特殊情况,
(1)如果前一个字符/或者后一个字符,不存在(越界),我们设为‘#’(只需要设置为小写字母之外的字符即可)
(2)如果后一个字符为‘?’,我们同样设置为‘#’

2.处理好特殊情况后,我们很容易得到 当前字符的左右相邻的字符

3.从a~z中选择一个 既不等于左边字符 又不等于右边字符 的小写字母即可

4.当然 直接在首尾预先插入‘#’,就不同特判越界的情况(本代码未添加,比赛直接写了,没想这么多)
代码:

class Solution
{
public:
    char fd(char p, char s)//选择一个合适的小写字母
    {
        for (char c = 'a'; c <= 'z'; c++)
        {
            if (c != p && c != s)
            {
                return c;
            }
        }
        return '#';
    }
    string modifyString(string s)
    {
        string t = "";
        for (int i = 0; i < s.length(); i++)
        {
            if (s[i] != '?')
            {
                t += s[i];
            }
            else
            {
                char x, y;
                if (i - 1 < 0)
                {
                    x = '#';
                }
                else
                {
                    x = t[i - 1];
                }
                if (i + 1 > s.length() - 1 || s[i + 1] == '?')
                {
                    y = '#';
                }
                else
                {
                    y = s[i + 1];
                }
                char tp = fd(x, y);
                t += tp;
            }
        }
        return t;
    }
};

T2. 数的平方等于两数乘积的方法数

给你两个整数数组 nums1 和 nums2 ,请你返回根据以下规则形成的三元组的数目(类型 1 和类型 2 ):

类型 1:三元组 (i, j, k) ,如果 nums1[i]2 == nums2[j] * nums2[k] 其中 0 <= i < nums1.length 且 0 <= j < k < nums2.length
类型 2:三元组 (i, j, k) ,如果 nums2[i]2 == nums1[j] * nums1[k] 其中 0 <= i < nums2.length 且 0 <= j < k < nums1.length

分析:
就是一个数组里的值,等于另外一个数组里两个元素的积

思路:
很直接,
1.预处理两个数组里所有不同元素的积
2.遍历每个数组,查询即可
注意!
数值范围爆int,要用long long

代码:

class Solution
{
     
public:
    typedef long ll;
    map<ll, ll> m1, m2;

    int numTriplets(vector<int> &nums1, vector<int> &nums2)
    {
     
        for (int i = 0; i < nums1.size(); i++)
        {
     
            for (int j = i + 1; j < nums1.size(); j++)
            {
     
                m1[(ll)nums1[i] * (ll)nums1[j]]++;
            }
        }
        for (int i = 0; i < nums2.size(); i++)
        {
     
            for (int j = i + 1; j < nums2.size(); j++)
            {
     
                m2[(ll)nums2[i] * (ll)nums2[j]]++;
            }
        }
        int sum = 0;
        for (int i = 0; i < nums1.size(); i++)
        {
     
            sum += m2[(ll)nums1[i] * (ll)nums1[i]];
        }
        for (int i = 0; i < nums2.size(); i++)
        {
     
            sum += m1[(ll)nums2[i] * (ll)nums2[i]];
        }

        return sum;
    }
};

T3.避免重复字母的最小删除成本
给你一个字符串 s 和一个整数数组 cost ,其中 cost[i] 是从 s 中删除字符 i 的代价。

返回使字符串任意相邻两个字母不相同的最小删除成本。

请注意,删除一个字符后,删除其他字符的成本不会改变。
示例 1:

输入:s = “abaac”, cost = [1,2,3,4,5]
输出:3
提示:

s.length == cost.length
1 <= s.length, cost.length <= 10^5
1 <= cost[i] <= 10^4
s 中只含有小写英文字母

分析:
看完题目,应该比较好分析
1.要使得相邻字母不同,那么我们要 对连续且字母相同的一段区间 进行处理了
2.怎么处理,我们需要将它删除得只剩下一个字符,如何删除使得成本最小
3.当然是保留这一段中cost最大的,剩余的全删除了
4.统计删除掉的cost总和,即答案

思路:
1.用栈保存字符相等且连续的一段区间。我们用sum记录区间cost和,用mx记录区间cost最大值
2.进栈时,
(1)如果栈顶元素与当前元素相等,则进栈,更新sum和mx
(2)若不同,清空栈,计算前一段连续区间的答案,然后在进栈,更新sum和mx
没啥坑,就是注意区间长度大于1才要计算答案

代码:

class Solution
{
     
public:
    int minCost(string s, vector<int> &cost)
    {
     
        stack<char> st;
        int sum, mx;
        int res = 0;
        sum = 0;
        mx = 0;
        for (int i = 0; i < s.length(); i++)
        {
     
            if (st.empty())
            {
     
                st.push(s[i]);
                sum = cost[i];
                mx = cost[i];
            }
            else
            {
     
                if (st.top() == s[i])
                {
     
                    st.push(s[i]);
                    sum += cost[i];
                    mx = max(mx, cost[i]);
                }
                else
                {
     
                    if (st.size() > 1)
                    {
     
                        res += (sum - mx);
                        //cout<
                        // cout<
                    }
                    while (!st.empty())
                    {
     
                        st.pop();
                    }
                    st.push(s[i]);

                    sum = mx = cost[i];
                }
            }
        }
        if (!st.empty() && st.size() > 1)
        {
     
            res += (sum - mx);
        }
        return res;
    }
};

T4.保证图可完全遍历
Alice 和 Bob 共有一个无向图,其中包含 n 个节点和 3 种类型的边:

类型 1:只能由 Alice 遍历。
类型 2:只能由 Bob 遍历。
类型 3:Alice 和 Bob 都可以遍历。
给你一个数组 edges ,其中 edges[i] = [typei, ui, vi] 表示节点 ui 和 vi 之间存在类型为 typei 的双向边。请你在保证图仍能够被 Alice和 Bob 完全遍历的前提下,找出可以删除的最大边数。如果从任何节点开始,Alice 和 Bob 都可以到达所有其他节点,则认为图是可以完全遍历的。

返回可以删除的最大边数,如果 Alice 和 Bob 无法完全遍历图,则返回 -1 。

链接:https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable

分析:
这个3个图叠加在一起的问题,我们分开考虑/分析
1.首先问题是 使图联通的情况下,可以删除的最大边数,好像不太熟悉,那转换一下,->使图联通的情况下,可以添加的最小边数!!!介不是MST(最小生成树)吗!
2.如果有公共边,我们肯定用公共边对不对?因为它一条边顶两条边用啊,保证添加最少边的性质
公共边组成的子图里怎么可以最简(边最少)呢?那就是最小生成树啊!!!
3.那么对于 Alice和 Bob 的图怎么处理,使得添加的边最少呢??
因为公共边已经处理(MST,最小生成树)好了,在公共边的基础上,如何添加边,让 Alice和 Bob 都能遍历
分别对 Alice的边和Bob 的边做MST,在公共边的基础上,分别对ALice和Bob的边集合,用kurskal添加边即可。

思路:
1.对 type3的边 单独做最小生树
2.1中最小生成树的基础上,分别type
1和type==2的边做最小生成树
3.经过1和 2,我们可以得到 添加最小边数使得 图“可完全遍历”的边数 ,用总边数减去即是答案
注意:用 并查集 判断 不能 保证图可完全遍历的情况

代码:

class Solution
{
     
public:
    int fa[100005];

    int fd(int x)
    {
     
        if (fa[x] != x)
        {
     
            fa[x] = fd(fa[x]);
        }
        else
        {
     
            return fa[x];
        }
        return fa[x];
    }
    void un(int x, int y)
    {
     
        int a, b;
        a = fd(x);
        b = fd(y);
        if (a != b)
        {
     
            fa[a] = b;
        }
    }
    void init()
    {
     
        for (int i = 1; i < 100005; i++)
            fa[i] = i;
    }
    bool ck(int n)
    {
     
        map<int, int> mp;
        //cout<
        for (int i = 1; i <= n; i++)
        {
     
            //cout<
            mp[fd(i)]++;
        }
        // cout<
        if (mp.size() > 1)
            return 0;
        return 1;
    }
    int maxNumEdgesToRemove(int n, vector<vector<int>> &edges)
    {
     
        int e3 = 0;

        int e2, e1;
        e2 = e1 = 0;
        int res = 0;
        init();
        for (auto v : edges)
        {
     
            if (v[0] == 3)
            {
     
                if (fd(v[1]) != fd(v[2]))
                {
     
                    un(v[1], v[2]);
                    e3++;
                    res++;
                }
            }
        }
        for (auto v : edges)
        {
     
            if (v[0] == 1)
            {
     
                if (fd(v[1]) != fd(v[2]))
                {
     
                    un(v[1], v[2]);
                    e1++;
                    res++;
                }
            }
        }
        if (!ck(n))
            return -1;
        init();
        for (auto v : edges)
        {
     
            if (v[0] == 3)
            {
     
                if (fd(v[1]) != fd(v[2]))
                {
     
                    un(v[1], v[2]);
                    e3++;
                    //res++;
                }
            }
        }
        for (auto v : edges)
        {
     
            if (v[0] == 2)
            {
     
                if (fd(v[1]) != fd(v[2]))
                {
     
                    un(v[1], v[2]);
                    e1++;
                    res++;
                }
            }
        }
        if (!ck(n))
            return -1;

        return edges.size() - res;
    }
};

总结:总体难度偏小,需要一点分析能力

你可能感兴趣的:(Leetcode周赛,Leetcode周赛)