智算之道-第一场初赛-题解

智算之道大赛 第一场初赛 题解

A - 排队

题目描述

小A现在站在一个$n$个人的队伍里排队，他们的编号依次为$1\sim n$，现在她面前有$m$个窗口，其中第 $i$ 个窗口会给出一个数字 $a_i$，然后将队伍中所有编号为$a_i$倍数的人带出队伍，请问最后队伍中还剩下多少个人？

输入格式

第一行两个用空格隔开的整数分别表示$n,m$
第二行$m$个用空格隔开的整数，其中第$i$个代表$a_i$

输出格式

输出一个整数，代表剩下多少个人

数据规模与约定

对于$30\%$的数据，$1\le n\le 100,1\le m\le 10$
对于$60\%$的数据，$1\le n\le 1000,1\le m\le 10$
对于$100\%$的数据，$1\le n\le 100000,1\le m\le 100,1\le a_i\le n$

解题思路及分析

循环遍历a数组，标记所有n以内a[i]的倍数，每标记一个结果减一，输出结果即可

AC代码

#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

int a[105];
bool out[100005];

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++)
    {
        scanf("%d", &a[i]);
    }
    int ans = n;
    for (int i = 0; i < m; i++)
    {
        for (int j = 1; a[i] * j <= n; j++)
        {
            if (!out[a[i] * j])
            {
                out[a[i] * j] = true;
                ans--;
            }
        }
    }
    printf("%d", ans);
    return 0;
}

---

B - 开关

题目描述

小B面前有$n$个开关，开始时第$i$个开关的状态是$a_i$ ，其中 $a_i=1$ 表示第$i$个开关是开的，$a_i=0$表示第$i$个开关是关的。现在小B获得了一种魔法，他可以进行若干次操作，每次操作可以选择一个数$x$，然后把$x$号开关及其之前的所有开关状态反转（开变关，关变开），请问小B最少需要多少次操作才能使所有开关都变为关的状态。

输入格式

第一行一个整数表示$n$
第二行为一个长度为$n$的$01$符串，即每一位只会是$0$或者$1$

输出格式

输出一个整数，表示最少需要多少次操作才能使所有开关都变为关的状态

数据规模与约定

对于$30\%$的数据，$1\le n\le 20$
对于$60\%$的数据，$1\le n\le 2000$
对于$100\%$的数据，$1\le n\le 200000$

解题思路及分析

从后往前遍历，遇到1之后把前面的数字反转

为了降低时间复杂度，在遇到1之后不是把前面的数字反转，而是将寻找的目标反转，只需要一次遍历即可得出结果，时间复杂度为O(n)

AC代码

#include <cstdio>
using namespace std;

int main()
{
    int n;
    char a[200005];
    scanf("%d%s", &n, a);
    int goal = 1, ans = 0;
    for (int i = n - 1; i >= 0; i--)
    {
        if (!(a[i] - '0' == goal))
        {
            goal = 1 - goal;
            ans++;
        }
    }
    printf("%d", ans);
    return 0;
}

---

C - 字符串

题目描述

给定两个字符串$S$和$T$，它们都只由小写字母组成。现在请计算出字符串$S$的本质不同的排列中有多少种是字符串$T$的子串。
本质不同，就是看起来不同，例如 aab 有$3$种本质不同的排列 aab, aba, baa。

输入格式

第一行有一个字符串$S$
第二行有一个字符串$T$

输出格式

输出一个整数表示字符串$S$的本质不同的排列中有多少种是字符串$T$的子串

数据规模与约定

对于$30\%$的数据，$1\le |S|\le 5,1\le |T|\le 200$
对于$60\%$的数据，$1\le |S|\le 2000,1\le |T|\le 2000$
对于$100\%$的数据，$1\le |S|\le 200000,1\le |T|\le 200000$

解题思路及分析

此题本人赛上只拿到 30分（菜是原罪）

暴力解法，循环遍历$S$的每个排列，判断$S$是否是$T$的子串
待我有了好的思路，再更新新的代码

---

2020.7.28
更新了90分代码和满分做法的思路
90分的方法是，用滑动窗口卡子串
如果窗口中的子串与$S$串中字符的个数和种类均相同
则为$S$的一个排列，放入set去重，最后输出集合的大小即可

评测机不支持C++11的unordered_map和unordered_set
同时记录$[l,r)$的字符串tmp也要消耗一定的时间，最后一个测试点超时

说一下满分的思路（结合参考了各路神仙的方法）
将set字符串去重改成字符串哈希，用vector存储 后面去重
tmp字符串计算改成用longlong计算类似前缀和的操作
能够拿到满分
哈希用的不熟，系统关了，也懒得写了，可以去看其他人的博客

30分代码

#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <iostream>
#include <cstring>
#include <string>
using namespace std;

bool IsSubStr(string t, int start, string s);

int main()
{
    long long ans = 0;
    string s, t;
    getline(cin, s);
    getline(cin, t);
    sort(s.begin(), s.end());
    do
    {
        for (int i = 0; i < t.size(); i++)
        {
            if (t[i] == s[0] && IsSubStr(t, i, s))
            {
                ans++;
                break;
            }
        }
    } while (next_permutation(s.begin(), s.end()));
    
    printf("%lld", ans);
    return 0;
}

bool IsSubStr(string t, int start, string s)
{
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] != t[i + start])
        {
            return false;
        }
    }
	return true;
}

90分代码

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <set>
#include <map>
using namespace std;

string s, t;
set<string> ss;
map<char, int> need;

int main()
{
    cin >> s >> t;
    // S只有一个字符时 可以单独拿出来判断
    if (s.size() == 1)
    {
        bool find = 0;
        for (int i = 0; i < t.size(); i++)
        {
            if (t[i] == s[0])
            {
                find = true;
                break;
            }
        }
        printf(find ? "1\n" : "0\n");
        return 0;
    }

    for (int i = 0; i < s.size(); i++)
        need[s[i]]++;
    int l = 0, r = 0;
    while (r < t.size())
    {
        if (!need.count(t[r]) || !need[t[r]])
        {
            while (l < r && t[l] != t[r])
            {
                need[t[l]]++;
                l++;
            }
            l++;
        }
        else
        {
            need[t[r]]--;
        }

        if (need.count(t[r]) && !need[t[r]] && (r - l + 1) == s.size())
        { 
            string tmp = "";
            for (int i = l; i < r; i++)
            {
                tmp += s[i];
            }
            ss.insert(tmp);
        }
        r++;
    }
    printf("%d\n", ss.size());
    return 0;
}