2021.11.14 力扣-周赛

最新推荐文章于 2024-09-16 21:26:45 发布

作用太大了销夜

最新推荐文章于 2024-09-16 21:26:45 发布

阅读量880

点赞数

分类专栏： leetcode 文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_52629904/article/details/121316173

版权

leetcode 专栏收录该内容

201 篇文章 0 订阅

订阅专栏

搞了几天的模糊数学大作业，都没怎么写代码，今天写个周赛放松一下。

这次的题目并不难，只是有点地方麻烦了点，第一次写出了3题，最后一题试了一会后发现是并查集的问题，早忘记咋写了，明天开始再练习练习并查集的题目。

题目一：买票需要的时间

题目描述：

有 n 个人前来排队买票，其中第 0 人站在队伍最前方，第 (n - 1) 人站在队伍最后方。

给你一个下标从 0 开始的整数数组 tickets ，数组长度为 n ，其中第 i 人想要购买的票数为 tickets[i] 。

每个人买票都需要用掉恰好 1 秒。一个人一次只能买一张票，如果需要购买更多票，他必须走到队尾重新排队（瞬间发生，不计时间）。如果一个人没有剩下需要买的票，那他将会离开队伍。

返回位于位置 k（下标从 0 开始）的人完成买票需要的时间（以秒为单位）。

方法一：

class Solution {
public:
    int timeRequiredToBuy(vector<int>& tickets, int k) {
        int ans = 0;
        int n = tickets.size();
        for (int i = 0; i < n; i = (i + 1) % n)
        {
            if (tickets[i] > 0)
            {
                tickets[i]--;
                ans++;
            }
            if (i == k && tickets[i] == 0)
            {
                break;
            }
        }
        return ans;
    }
};

第一道简单题一般都是能直接暴力通过的，能省点时间就省点。

题目二：反转偶数长度组的节点

题目描述：

给你一个链表的头节点 head 。

链表中的节点按顺序划分成若干非空组，这些非空组的长度构成一个自然数序列（1, 2, 3, 4, ...）。一个组的长度就是组中分配到的节点数目。换句话说：

节点 1 分配给第一组
节点 2 和 3 分配给第二组
节点 4、5 和 6 分配给第三组，以此类推
注意，最后一组的长度可能小于或者等于 1 + 倒数第二组的长度。

反转每个偶数长度组中的节点，并返回修改后链表的头节点 head 。

方法一：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseEvenLengthGroups(ListNode* head) {
        ListNode* dumbnode = new ListNode();
        dumbnode->next = head;
        ListNode* temp = head;
        int n = 0;
        while (temp != nullptr)
        {
            n++;
            temp = temp->next;
        }
        int grouplength = 1;
        ListNode* left = dumbnode;
        ListNode* right = head;
        while (right != nullptr)
        {
            //cout << "  " << endl;
            //cout << grouplength << endl;
            //cout << n << endl;
            if ((grouplength % 2 == 0 && grouplength <= n) || (grouplength > n && n % 2 == 0))
            {
                ListNode* pre1 = left;
                ListNode* pre2 = right;
                left = left->next;
                right = right->next;
                for (int i = 0; i < min(grouplength, n) - 1; i++)
                {
                    ListNode* temp = right->next;
                    right->next = left;
                    left = right;
                    right = temp;
                }
                pre1->next = left;
                pre2->next = right;
                left = pre2;
            }
            else
            {
                for (int i = 0; i < min(grouplength, n); i++)
                {
                    left = left->next;
                    right = right->next;
                    //if (right == nullptr)
                    //{
                    //    break;
                    //}
                }
            }
            n -= grouplength;
            grouplength++;
        }
        return dumbnode->next;
    }
};

耗时最久的一道题，还是自己不熟练吧，对于一个一个的节点，在纸上数的都快乱了。

先遍历一下计算出链表的长度，用于判断当链表到头时，最后一组的长度是否是偶数长度。

对于每一组如果是偶数长度就反转，否则就遍历直至下一组。

题目三：解码斜向换位密码

题目描述：

字符串 originalText 使用斜向换位密码，经由行数固定为 rows 的矩阵辅助，加密得到一个字符串 encodedText 。

originalText 先按从左上到右下的方式放置到矩阵中。

先填充蓝色单元格，接着是红色单元格，然后是黄色单元格，以此类推，直到到达 originalText 末尾。箭头指示顺序即为单元格填充顺序。所有空单元格用 ' ' 进行填充。矩阵的列数需满足：用 originalText 填充之后，最右侧列不为空。

接着按行将字符附加到矩阵中，构造 encodedText 。

先把蓝色单元格中的字符附加到 encodedText 中，接着是红色单元格，最后是黄色单元格。箭头指示单元格访问顺序。

例如，如果 originalText = "cipher" 且 rows = 3 ，那么我们可以按下述方法将其编码：

蓝色箭头标识 originalText 是如何放入矩阵中的，红色箭头标识形成 encodedText 的顺序。在上述例子中，encodedText = "ch ie pr" 。

给你编码后的字符串 encodedText 和矩阵的行数 rows ，返回源字符串 originalText 。

注意：originalText 不含任何尾随空格 ' ' 。生成的测试用例满足仅存在一个可能的 originalText 。

方法一：

class Solution {
public:
    string decodeCiphertext(string encodedText, int rows) {
        int len = encodedText.size();
        int m = rows;
        int n = len / m;
        vector<vector<char>> code(m, vector<char>(n));
        int c = 0;
        int count = 0;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                code[i][j] = encodedText[c];
                if (encodedText[c] != ' ')
                {
                    count++;
                }
                c++;
            }
        }
        string ans;
        int x = 0;
        int y = 0;
        int temp = 0;
        int col = 0;
        while (temp < count)
        {
            if (code[x][y] != ' ')
            {
                temp++;
            }
            ans.push_back(code[x][y]);
            x++;
            y++;
            if (x == m || y == n)
            {
                col++;
                x = 0;
                y = col;
            }
        }
        return ans;
    }
};

直接用一个二维数组来存储encodedText字符串即可，然后再从二维数组中提取出所想要的字符串originalText。

由于originalText的最后一位一定不是 ' ' ，所以可以先记录下encodeText中非空格的字母个数，只有读完了所有的字母之后，才说明在二维数组中已经读完了originalText，否则每次读到一个空字符，都不知道是否到头。