Acwing66周赛+Leetcode308周赛

Acwing66周赛+Leetcode308周赛

ACW

link题目链接

这次的周赛又划水了 ，是真的划水了 hhh
去湖州漂流hh

第二题字母补齐
简单而言就是构造一个hash表，遍历string 。。。

第三题

给定一个包含 n 个整数 s1,s2,…,sn 的集合 S。

我们规定，如果某个整数在一个集合中恰好出现一次，则称该整数为超级数。

例如，集合 {1,1,2,3,3,3,4} 中包含两个超级数 2,4。

现在，请你将 S 分成两个集合 A 和 B（其中一个可以为空），使得集合 A 中超级数的数量与集合 B 中超级数的数量相同（也就是说，集合 A 中恰好出现一次的整数的数量与集合 B 中恰好出现一次的整数的数量相同）。

输入格式
第一行包含一个整数 n。

第二行包含 n 个整数 s1,s2,…,sn。

输出格式
如果不存在合理的划分方案，则输出一行 NO。

否则，第一行输出 YES，第二行输出一个长度为 n 的由 A 和 B 构成的字符串，其中的第 i 个字符，如果为 A 则表示 si 划分到集合 A，如果为 B 则表示 si 划分到集合 B。

如果方案不唯一，输出任意合理方案均可。

数据范围
前 6 个测试点满足 2≤n≤12。
所有测试点满足 2≤n≤100，1≤si≤100。

输入样例1：
4
3 5 7 1
输出样例1：
YES
BABA
输入样例2：
3
3 5 1
输出样例2：
NO

我们构造一个vector p;
对于数字1 p[1].push_back() 记录存在的位置
我们首先直接计算出超级数的个数 cnt
若cnt 为偶数 可以直接操作
若cnt 为奇数 我们对非超级数进行如下处理
1.当此数字出现次数为2时 我们发现无论放在a中还是b中对结果没有影响
2.当此数字出现次数大于2时，我们只需要将一个数字放在a中，其余数字均放入b 此时可以呈现a中超级数比b中多1
3.如果剩下的数字均不大于2，可得无解
实现代码如下

#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 110;

int n;
vector<int> p[N];

int main()
{
    cin >> n;

    for (int i = 0; i < n; i ++ )
    {
        int x;
        cin >> x;
        p[x].push_back(i);
    }

    int cnt = 0;
    for (int i = 0; i < N; i ++ )
        if (p[i].size() == 1)
            cnt ++ ;

    string res(n, 'A');
    for (int i = 0, k = 0; i < N; i ++ )
        if (p[i].size() == 1)
        {
            k ++ ;
            if (k <= cnt / 2) res[p[i][0]] = 'A';
            else res[p[i][0]] = 'B';
        }

    bool flag = true;
    if (cnt % 2)
    {
        flag = false;
        for (int i = 0; i < N; i ++ )
            if (p[i].size() > 2)
            {
                flag = true;
                res[p[i][0]] = 'A';
                for (int j = 1; j < p[i].size(); j ++ )
                    res[p[i][j]] = 'B';
                break;
            }
    }

    if (flag)
    {
        puts("YES");
        cout << res << endl;
    }
    else puts("NO");

    return 0;
}

Leetcode

link原题链接
前三题均可暴力ac

给你一个 正 整数 k ，同时给你：

一个大小为 n 的二维整数数组 rowConditions ，其中 rowConditions[i] = [abovei, belowi] 和
一个大小为 m 的二维整数数组 colConditions ，其中 colConditions[i] = [lefti, righti] 。
两个数组里的整数都是 1 到 k 之间的数字。

你需要构造一个 k x k 的矩阵，1 到 k 每个数字需要 恰好出现一次 。剩余的数字都是 0 。

矩阵还需要满足以下条件：

对于所有 0 到 n - 1 之间的下标 i ，数字 abovei 所在的 行 必须在数字 belowi 所在行的上面。
对于所有 0 到 m - 1 之间的下标 i ，数字 lefti 所在的 列 必须在数字 righti 所在列的左边。
返回满足上述要求的 任意 矩阵。如果不存在答案，返回一个空的矩阵。

 

示例 1：



输入：k = 3, rowConditions = [[1,2],[3,2]], colConditions = [[2,1],[3,2]]
输出：[[3,0,0],[0,0,1],[0,2,0]]
解释：上图为一个符合所有条件的矩阵。
行要求如下：
- 数字 1 在第 1 行，数字 2 在第 2 行，1 在 2 的上面。
- 数字 3 在第 0 行，数字 2 在第 2 行，3 在 2 的上面。
列要求如下：
- 数字 2 在第 1 列，数字 1 在第 2 列，2 在 1 的左边。
- 数字 3 在第 0 列，数字 2 在第 1 列，3 在 2 的左边。
注意，可能有多种正确的答案。
示例 2：

输入：k = 3, rowConditions = [[1,2],[2,3],[3,1],[2,3]], colConditions = [[2,1]]
输出：[]
解释：由前两个条件可以得到 3 在 1 的下面，但第三个条件是 3 在 1 的上面。
没有符合条件的矩阵存在，所以我们返回空矩阵。
 

提示：

2 <= k <= 400
1 <= rowConditions.length, colConditions.length <= 104
rowConditions[i].length == colConditions[i].length == 2
1 <= abovei, belowi, lefti, righti <= k
abovei != belowi
lefti != righti

我们首先可以观察到上下的位置和左右的位置是无关的，
对此我们可以很容易观察对于上下位置和左右位置均可进行一次top-sort()
如果出现环即可说明无解
求出上下位置的top-sort后 对于左右位置，只需按需插入即可

给定条件下构造矩阵
提交记录
51 / 53 个通过测试用例
状态：通过
执行用时: 116 ms
内存消耗: 54.9 MB
提交时间：2 天前
执行用时分布图表
执行消耗内存分布图表
邀请好友来挑战 给定条件下构造矩阵
提交的代码： 2 天前
语言： cpp

添加备注



class Solution {
    vector<int> topo_sort(int k, vector<vector<int>> &edges) {
        vector<vector<int>> g(k);
        vector<int> in_deg(k);
        for (auto &e : edges) {
            int x = e[0] - 1, y = e[1] - 1; // 顶点编号从 0 开始，方便计算
            g[x].push_back(y);
            ++in_deg[y];
        }

        vector<int> order;
        queue<int> q;
        for (int i = 0; i < k; ++i)
            if (in_deg[i] == 0)
                q.push(i);
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            order.push_back(x);
            for (int y : g[x])
                if (--in_deg[y] == 0)
                    q.push(y);
        }
        return order;
    }

public:
    vector<vector<int>> buildMatrix(int k, vector<vector<int>> &rowConditions, vector<vector<int>> &colConditions) {
        auto row = topo_sort(k, rowConditions), col = topo_sort(k, colConditions);
        if (row.size() < k || col.size() < k) return {};
        vector<int> pos(k);
        for (int i = 0; i < k; ++i)
            pos[col[i]] = i;
        vector<vector<int>> ans(k, vector<int>(k));
        for (int i = 0; i < k; ++i)
            ans[i][pos[row[i]]] = row[i] + 1;
        return ans;
    }
};

这次周三相较于之前简单很多hhh