力扣第284场周赛题解

A.6031. 找出数组中的所有 K 近邻下标

找到每个 n u m s [ j ] = = k e y nums[j] == key nums[j]==key j j j,将所有 m a x ( 0 , j − k ) , m i n ( j + k , n − 1 ) max(0,j-k),min(j+k,n-1) max(0,jk),min(j+k,n1)的下标都统计起来即可。 1 < = n u m s . l e n g t h < = 1000 1 <= nums.length <= 1000 1<=nums.length<=1000,不需要优化可以直接 O ( n 2 ) O(n^2) O(n2)过。

AC代码:

class Solution
{
public:
    vector<int> findKDistantIndices(vector<int> &nums, int key, int k)
    {
        int n = nums.size();
        set<int> st;
        for (int i = 0; i < n; i++)
            if (nums[i] == key)
                for (int j = max(0, i - k); j <= min(n - 1, i + k); j++)
                    st.insert(j);
        vector<int> ans;
        for (auto it : st)
            ans.emplace_back(it);
        return ans;
    }
};

B.5203. 统计可以提取的工件

看上去题目很复杂,但是题目保证了每个 d i g dig dig元素都不重复,也即每次挖掘都不重复,那么只需要统计面积 == 挖掘次数的元件数量即可。

AC代码:

class Solution
{
public:
    int digArtifacts(int n, vector<vector<int>> &artifacts, vector<vector<int>> &dig)
    {
        map<int, int> num;
        int mp[1010][1010];
        memset(mp, 0, sizeof mp);
        int id = 0;//给元件编号
        for (auto it : artifacts)
        {
            num[++id] = (it[2] - it[0] + 1) * (it[3] - it[1] + 1);
            for (int i = it[0]; i <= it[2]; i++)
                for (int j = it[1]; j <= it[3]; j++)
                    mp[i][j] = id;
        }
        int ans = 0;
        for (auto it : dig)
        {
            int val = mp[it[0]][it[1]];
            if (num[val] == 1)
                ans++;
            else
                num[val]--;
        }
        return ans;
    }
};

C.5227. K 次操作后最大化顶端元素

前排也wa的挺惨的,个人感觉题目有歧义。

两种情况:

  1. 先使用 k − 1 k-1 k1次把前 k − 1 k-1 k1个元素删除,最后一次恢复已删除中的最大值。
  2. 删除前 k k k个元素。

还有 − 1 -1 1 以及 k > n k>n k>n的特殊情况,special judge 即可。

AC代码:

class Solution
{
public:
    int maximumTop(vector<int> &nums, int k)
    {
        int ans = 0, mx = 0;
        int n = nums.size();
        if (n == 1 && k % 2)
            return -1;
        for (auto it : nums)
            mx = max(mx, it);
        if (k > n)
            return mx;

        int p = min(n, k - 1);
        for (int i = 0; i < p; i++)
            ans = max(ans, nums[i]);
        if (p + 1 < n)
            ans = max(ans, nums[p + 1]);
        return ans;
    }
};

D.6032. 得到要求路径的最小带权子图

  1. 从起点1出发,求出到各个点的最短距离 d i s 1 [ ] dis1[] dis1[]
  2. 从起点2出发,求出到各个点的最短距离 d i s 2 [ ] dis2[] dis2[]
  3. 建反图,从终点出发,求出到各个点的最短距离 d i s 3 [ ] dis3[] dis3[]

答案就是 min ⁡ 0 n − 1 d i s 1 [ i ] + d i s 2 [ i ] + d i s 3 [ i ] \min ^{n-1}_0{dis1[i]+dis2[i]+dis3[i]} min0n1dis1[i]+dis2[i]+dis3[i]

AC代码:

class Solution
{
public:
    long long minimumWeight(int n, vector<vector<int>> &edges, int src1, int src2, int dest)
    {
        const int N = 1e5 + 5;
        vector<pair<int, int>> mp[N], rev_mp[N];
        long long dis1[N], dis2[N], dis3[N];
        int vis1[N], vis2[N], vis3[N];

        for (auto it : edges)
        {
            mp[it[0]].emplace_back(make_pair(it[1], it[2]));
            rev_mp[it[1]].emplace_back(make_pair(it[0], it[2]));
        }
        for (int i = 0; i < n; i++)
        {
            dis1[i] = dis2[i] = dis3[i] = 1e18;
            vis1[i] = vis2[i] = vis3[i] = 0;
        }

        priority_queue<pair<long long, int>> q;
        dis1[src1] = 0;
        q.push(make_pair(0, src1));
        while (q.size()) // src1 出发 单源最短路
        {
            int u = q.top().second;
            long long w = -q.top().first;
            q.pop();
            if (vis1[u])
                continue;
            vis1[u] = 1;
            for (auto it : mp[u])
            {
                int v = it.first;
                if (w + it.second < dis1[v])
                {
                    dis1[v] = w + it.second;
                    q.push(make_pair(-dis1[v], v));
                }
            }
        }

        dis2[src2] = 0;
        q.push(make_pair(0, src2));
        while (q.size()) // src2 出发 单源最短路
        {
            int u = q.top().second;
            long long w = -q.top().first;
            q.pop();
            if (vis2[u])
                continue;
            vis2[u] = 1;
            for (auto it : mp[u])
            {
                int v = it.first;
                if (w + it.second < dis2[v])
                {
                    dis2[v] = w + it.second;
                    q.push(make_pair(-dis2[v], v));
                }
            }
        }

        dis3[dest] = 0;
        q.push(make_pair(0, dest));
        while (q.size()) //反图  dest 出发 单源最短路
        {
            int u = q.top().second;
            long long w = -q.top().first;
            q.pop();
            if (vis3[u])
                continue;
            vis3[u] = 1;
            for (auto it : rev_mp[u])
            {
                int v = it.first;
                if (w + it.second < dis3[v])
                {
                    dis3[v] = w + it.second;
                    q.push(make_pair(-dis3[v], v));
                }
            }
        }
        long long ans = 1e18;
        for (int i = 0; i < n; i++)
            ans = min(ans, dis1[i] + dis2[i] + dis3[i]);
        return ans == 1e18 ? -1 : ans;
    }
};
  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
题目描述: 给出两个非空链表来表示两个非负整数。其中,它们各自的位数是按照逆序的方式存储的,并且它们的每个节点只能存储一位数字。 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这两个数都不会以零开头。 示例: 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出:7 -> 0 -> 8 原因:342 + 465 = 807 解题思路: 题目中要求我们按照逆序的方式存储两个非负整数,也就是说链表的头节点表示该数的个位,第二个节点表示该数的十位,以此类推。 因此,我们可以从两个链表的头节点开始,对应位相加,并记录进位,将结果添加到新的链表中。如果有进位,需要在下一位相加时加上进位。 需要注意的是,当两个链表的长度不一致时,可以将较短的链表的缺失位看作是 0。 最后,如果最高位有进位,还需要在新链表的最高位添加一个值为 1 的节点。 C 语言代码实现: /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){ struct ListNode *head = NULL, *tail = NULL; int carry = 0; while (l1 || l2) { int n1 = l1 ? l1->val : 0; int n2 = l2 ? l2->val : 0; int sum = n1 + n2 + carry; if (!head) { head = tail = malloc(sizeof(struct ListNode)); tail->val = sum % 10; tail->next = NULL; } else { tail->next = malloc(sizeof(struct ListNode)); tail = tail->next; tail->val = sum % 10; tail->next = NULL; } carry = sum / 10; if (l1) l1 = l1->next; if (l2) l2 = l2->next; } if (carry > 0) { tail->next = malloc(sizeof(struct ListNode)); tail = tail->next; tail->val = carry; tail->next = NULL; } return head; }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hesorchen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值