C++笔试强训day4

目录

1.游游的you

2.腐烂的苹果

3.孩子们的游戏

---

1.游游的you

链接：

分析题意之后，发现就是一道简单的贪心，当然也可以把他看作纯数学题。

因为you和oo里面都有o，但是you可以得两分，所以贪心策略尽可能的去凑更多的you，剩下的o则是n - 1分。

详细代码：

#include <iostream>
using namespace std;

int x,y,z;

int main() {
    int n;
    cin >> n;

    while(n--)
    {
        cin >> x >> y >> z;

        int mi = min(x,min(y,z));

        y -= mi;
        if(y > 0)
            cout << mi * 2 + y - 1 << endl;
        else
            cout << mi * 2 << endl;
    }   
}

注意：

要判断剩下的y是否大于0，不然会导致部分样例出错。

2.腐烂的苹果

链接

我一开始分析这道题目的时候，想到的竟然是DFS遍历，压根做不出来，因为做不到多源搜索。

正解应该是BFS的多源搜索。

首先先遍历grid，将所有的腐烂苹果存入队列，进行多源搜索。

最后需要返回的时候应该判断有没有苹果1没被感染到。

详细代码：

class Solution {
public:
    const static int N = 1010;
    int dx[4] = { 0, 0, 1, -1 };
    int dy[4] = { 1, -1, 0, 0 };
    bool vis[N][N] = { false };
    int m, n;
    int time = 0;

    queue<pair<int, int>> q;

    void BFS(vector<vector<int> >& grid) {

        while (q.size()) {
            time++;
            int size = q.size();
            while (size--) {
                int x = q.front().first;
                int y = q.front().second;
                q.pop();

                for (int i = 0; i < 4; ++i) {
                    int a = x + dx[i];
                    int b = y + dy[i];

                    if (a >= 0 && a < m && b >= 0 && b < n
                        && grid[a][b] == 1 && !vis[a][b]) {
                        vis[a][b] = true;
                        q.push({ a, b });
                    }
                }
            }
        }
    }

    int rotApple(vector<vector<int> >& grid) {
        m = grid.size();
        n = grid[0].size();

        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 2) {
                    q.push({ i, j });
                }
            }
        }

        // BFS遍历
        BFS(grid);
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1 && !vis[i][j])
                    return -1;
            }
        }

        return time - 1;//最后的苹果还会进行一次无效遍历  减掉那次
    }
};

怎么说呢，算是一道比较难的题目吧，个人觉得。

3.孩子们的游戏

链接

就是约瑟夫的环形链表。

方法一：模拟

可以用环形链表或者数组来模拟实现：

（这里我写的是环形链表）

class Solution {
public:
    typedef struct ListNode ListNode;

    ListNode* ListBuyNode(int x) {
        ListNode* node = (ListNode*)malloc(sizeof(ListNode));
        if (node == NULL) {
            perror("malloc fail!");
            exit(1);
        }
        node->val = x;
        node->next = NULL;
        return node;
    }

    //创建带环链表
    ListNode* CreateList(int n) {
        ListNode* phead = ListBuyNode(1);
        ListNode* ptail = phead;
        for (int i = 2; i <= n; i++) {
            ListNode* node = ListBuyNode(i);
            ptail->next = node;
            ptail = ptail->next;
        }
        ptail->next = phead;
        return ptail;
    }

    //n = 5;m = 2;
    int LastRemaining_Solution(int n, int m) {
        ListNode* prev = CreateList(n);
        ListNode* cur = prev->next;
        int count = 1;
        while (cur->next != cur) {
            if (count == m) {
                //杀掉
                prev->next = cur->next;
                free(cur);
                cur = prev->next;
                count = 1;
            }
            else {
                prev = cur;
                cur = cur->next;
                count++;
            }
        }
        return cur->val - 1;
    }
};

减一是因为我写的是从1开始的，而题目是从0开始。

方法二：递推/ 动态规划

就是只需要寻找 dp[n] 和 dp[n - 1] 的映射关系就好了。

图中所画的内环是i - 1，外环是i。分析很容易得到dp[i]与dp[i - 1]的关系为dp[i] = dp[i - 1] + m。

最后为了防止+m后超出n，因此模上一个n（目前的数量）。

因此：

class Solution 
{
  public:
    int dp[5010];
    
    int LastRemaining_Solution(int n, int m) 
    {
        dp[1] = 0;
        for (int i = 2; i <= n; i++) 
            dp[i] = (dp[i - 1] + m) % i;
        return dp[n];
    }
};

因为只有一维，而且状态转移方程只涉及一个数，也可以不创建dp表，用一个变量来表示。

class Solution
{
public:
    int LastRemaining_Solution(int n, int m)
    {
        int f = 0;
        for (int i = 2; i <= n; i++) f = (f + m) % i;
        return f;
    }
};