提出 fbbeba8e-cbea-4495-bf1b-e5efb5f6cce8

コード

#ifndef MAIN
#define MAIN
#include __FILE__
#define mp make_pair

string toup(string s)
{
    rep(i, s.at(i)) {
        if (s.at(i) >= 'a' && s.at(i) <= 'z') {
            s.at(i) -= 32;
        }
    }
    return s;
}

string tolow(string s)
{
    rep(i, s.at(i)) {
        if (s.at(i) >= 'A' && s.at(i) <= 'Z') {
            s.at(i) += 32;
        }
    }
    return s;
}

bool isPalindrome(const std::string& str) {
    int left = 0;
    int right = str.size() - 1;
    while (left < right) {
        if (str[left] != str[right]) {
            return false;
        }
        ++left;
        --right;
    }
    return true;
}

void _main()
{
    cint(n,m);
    set<pair<int,int>> pairs;
    rep(i,m){
        cint(a,b);
        pairs.insert(mp(a,b));
    }
    cint(q);
    vector<vector<int>> que(q,vector<int>(3));
    rep(i,q){
        cint(command);
        que[i][0]=command;
        if(command==1){
            cint(s,t);
            que[i][1]=s;
            que[i][2]=t;
            pairs.erase(mp(s,t));
        }
        else if(command==2){
            cint(s,t);
            que[i][1]=s;
            que[i][2]=t;
        }
        else {
            cint(x);
            que[i][1]=x;
        }
    }
    dsu d(n + 1);
    vector<string> outputs;
    for(auto x : pairs){
        d.merge(x.first,x.second);
    }
    for(int i=q-1;i>=0;i--){
        if(que[i][0]==1){
            d.merge(que[i][1],que[i][2]);
        }
        else if(que[i][0]==2){
            if(d.same(que[i][1],que[i][2])){
                outputs.push_back("Yes");
            }
            else{
                outputs.push_back("No");
            }
        }
        else if(que[i][0]==3){
            string s="";
            repf(t,1,n+1){
                if(d.same(que[i][1],t)){
                    s+=to_string(t);
                    s+=" ";
                }
            }
            outputs.push_back(s);
        }
        else{
            outputs.push_back(to_string(d.size(que[i][1])));
        }
    }
    for(int i = outputs.size()-1;i>=0;i--){
        cout<<outputs[i]<<endl;
    }
}

#else
#define MAIN
//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")

#if __has_include(<bits/stdc++.h>)
#include <bits/stdc++.h>
#else
import std;
#endif
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
using modint10 = modint1000000007;
using motint9 = modint998244353;
#endif
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<string> strvec;

constexpr ll mod10 = 1000000007;
constexpr ll mod9 = 998244353;
constexpr ll inf = 10000000000000000;

#define int ll
#define double ld
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repf(i, s, n) for (int i = s; i < (int)(n); i++)
template <class... Args>
void __y_input(Args &...arg)
{
    (cin >> ... >> arg);
}

template <class... Args>
void __y_input_vec_1(int p, Args &...args)
{
    (cin >> ... >> args[p]);
}
template <class Arg>
void __y_input_vec_resize(int size, Arg& arg)
{
    arg.resize(size);
}
template <class... Args>
void __y_input_vec(int n, Args &...args)
{
    (__y_input_vec_resize(n, args), ...);
    rep(i, n)
    {
        (__y_input_vec_1(i, args), ...);
    }
}

#define cint(...)  \
    int __VA_ARGS__; \
    __y_input(__VA_ARGS__)

#define cdbl(...)     \
    double __VA_ARGS__; \
    __y_input(__VA_ARGS__)

#define cstr(...)     \
    string __VA_ARGS__; \
    __y_input(__VA_ARGS__)

#define cit(t, ...) \
    t __VA_ARGS__;    \
    __y_input(__VA_ARGS__)

#define cvec(n, ...)       \
    vector<int> __VA_ARGS__; \
    __y_input_vec(n, __VA_ARGS__)

#define cvect(t, n, ...) \
    vector<t> __VA_ARGS__; \
    __y_input_vec(n, __VA_ARGS__)

#define last cout << endl
#define yn(bl) (bl ? "Yes" : "No")

ostream& yesno(bool bl)
{
    cout << yn(bl);
    return cout;
}
typedef array<int, 2> xy;
typedef array<int, 3> xyz;

template <typename T>
inline void sort(T& vec)
{
    return sort(vec.begin(), vec.end());
}
template <typename T>
inline void rsort(T& vec)
{
    return sort(vec.rbegin(), vec.rend());
}

namespace __yc
{
    template <typename T>
    struct __set : public std::set<T>
    {
        inline void Merge(set<T>& other)
        {
            if (this->size() < other.size())
            {
                other.merge(*this);
                swap(*this, other);
            }
            else
            {
                this->merge(other);
            }
            return;
        }
    };
    template <typename T>
    struct set : public __set<T>
    {
        inline void merge(set<T>& other)
        {
            this->Merge(other);
        }
    };
}

#define set __yc::set

void _main();
signed main()
{
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    _main();
    return 0;
}

#endif
結果

問題	点数	言語	結果	実行時間	メモリ
G - Breaking Friends	120	C++	WA	458 ms	32420 KiB