AtCoder Beginner Contest 235

AtCoder Beginner Contest 235

A - Rotate

思路分析：

• 因为他给的数是三位数，我们直接取出每一位，然后拼凑就可以了

代码如下：

#include <bits/stdc++.h>
#define int long long
using namespace std;

signed main()
{
        int x;
        cin >> x;
        int ans = 0;
        int a[3];
        a[0] = x / 10 % 10; // 第二位b
        a[1] = x % 10;      //第一位c
        a[2] = x / 100;     //三位a
        ans = ans + a[2] * 100 + a[0] * 10 + a[1] * 1;
        ans = ans + a[0] * 100 + a[1] * 10 + a[2] * 1;
        ans = ans + a[1] * 100 + a[2] * 10 + a[0] * 1;
        cout << ans << endl;
        return 0;
}

B - Climbing Takahashi

思路分析：

• 题目意思就是给你一个数组，然后一直往右走，当碰到右边的数不必当前位置大就停下，输出当前位置的值

代码如下：

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn];
signed main()
{
        int n;
        cin >> n;
        for (int i = 0; i < n; i++)
        {
                cin >> a[i];
        }
        int ans = a[0];
        for (int i = 1; i < n; i++)
        {
                if (a[i] > ans)
                {
                        ans = a[i];
                }
                else
                        break;
        }
        cout << ans << endl;
        return 0;
}

C - The Kth Time Query

思路分析：

• 题目的意思是要你找到给你的数组里面出现第$k_i$次的$x_i$的下标，我的想法是用一个map套一个vector，用来保存某个值在数组中的位置的集合，那么如果我们的这个vector的$size$小于$k_i$的话，就代表没有第$k_i$个$x_i$，然后输出-1，如果有的话，我们输出map[$x_i$][$k_i$]即可

代码如下：

#include <bits/stdc++.h>
using namespace std;
int main()
{
        int n, q;
        cin >> n >> q;
        map<int, vector<int>> f;
        for (int i = 1; i <= n; i++)
        {
                int a;
                cin >> a;
                f[a].push_back(i);
        }
        while (q--)
        {
                int x, k;
                cin >> x >> k;
                k--;
                if (f[x].size() > k)
                        cout << f[x][k] << endl;
                else
                        cout << -1 << endl;
        }
}

D - Multiply and Rotate

思路分析：

• 对于一个小于10的数，我们只有一种操作；对于一个大于10并且最后一位不是0的数，我们就有两种操作
• 考虑用bfs解决这题，我们用队列存pair，pair第一维表示当前数的值，第二位表示变成当前数的操作次数，我们可以知道队列是先进先出，所以保证了我们只要得到一个当前数等于要得到的数，我们直接输出即可。
• 然后由于我们要得到的数必然会小于1e6，我们就可以进行剪枝，只要得到的当前数大于了1e6，就不需要再入队了。还有能剪枝的地方就是只要当前数在前面出现过的话，我们也不需要再将它入队了，这样的话就不会TLE。

代码如下：

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
int main()
{
        int a, N;
        cin >> a >> N;
        vector<bool> seen(1e6 + 10, false);
        queue<pll> que;
        seen[1] = true;
        que.push({1, 0});
        int ans = -1;
        while (!que.empty())
        {
                pll vp = que.front();
                que.pop();
                if (vp.fi >= 1e6)
                        continue;
                if (vp.fi == N)
                {
                        ans = vp.se;
                        break;
                }
                ll n1 = vp.fi * a;
                if (n1 < 1e6 && !seen[n1])
                {
                        seen[n1] = true;
                        que.push({n1, vp.se + 1});
                }
                if (vp.fi > 10 && vp.fi % 10 != 0)
                {
                        string s = to_string(vp.fi);
                        ll n2 = vp.fi / 10;
                        n2 += (vp.fi % 10) * pow(10, s.size() - 1);
                        if (n2 < 1e6 && !seen[n2])
                        {
                                seen[n2] = true;
                                que.push({n2, vp.se + 1});
                        }
                }
        }
        cout << ans << endl;
}

E - MST + 1

思路分析：

• 这题赛时想复杂了，以为先要把生成树构造出来，再去将每个边进行比较，然后发现WA了，最后通过看题解把这题写出来了。
• 思路是什么呢？首先我们要把所有边全部读入(q + m)，但是超过m条的边我们用一个标记 i-m记录就可以了，m条以内用标记-1记录，以示区分。
• 然后就先对这q + m条边排序，一部分和克鲁斯卡尔算法一样，也就是说如果在同一个连通分量我们不需要加边。
• 区别就在于如果不在同一个连通分量，那么我们就看看它的标记是-1还是其它的，如果是-1，则表示它不是询问要加的边，我们直接正常操作就可以了；如果不是-1，它就是询问的边，我们就直接再用ans数组来标记第几条边(i - m)如果加上，它会在新生成的最小生成树里(注意这里不需要cnt++以及合并，即如果判断标记不为-1，我们用ans数组标记就直接continue)。

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int fa[maxn];
int ans[maxn];
int n, m, q;
struct edge
{
        int u, v, w, f;
        edge() { f = -1; }
        bool operator<(const edge &j) const
        {
                return w < j.w;
        }
} edges[maxn << 1];
int find(int x)
{
        return (x == fa[x] ? fa[x] : fa[x] = find(fa[x]));
}
signed main()
{
        cin >> n >> m >> q;
        for (int i = 1; i <= n; i++)
                fa[i] = i;
        memset(ans, 0, sizeof(ans));
        for (int i = 0; i < m + q; i++)
        {
                int u, v, w;
                cin >> u >> v >> w;
                edges[i].u = u;
                edges[i].v = v;
                edges[i].w = w;
                if (i >= m)
                {
                        edges[i].f = i - m;
                }
        }
        sort(edges, edges + q + m);
        //先sort
        int cnt = 0; // cnt == n - 1 break;
        for (int i = 0; i < m + q; i++)
        {
                if (cnt == n - 1)
                {
                        break;
                }
                int u = edges[i].u;
                int v = edges[i].v;
                int fu = find(u);
                int fv = find(v);
                if (fu != fv)
                {
                        if (edges[i].f != -1)
                        {
                                ans[edges[i].f] = 1;
                                continue;
                        }
                        fa[fu] = fv;
                        cnt++;
                }
        }
        for (int i = 0; i < q; i++)
        {
                printf("%s\n", (ans[i] == 1 ? "Yes" : "No"));
        }
        return 0;
}

F - Variety of Digits 待补

思路分析：

代码如下：