bool visited[200005];

void dfs(vector<vector<int>> g, int n, int m, int node)
{
    if (visited[node]) return;
    visited[node]=true;
    for (auto nxt : g[node]) dfs(g,n,m,nxt);
}

$$$\mathcal{O}((n+m)^2)$$$

The DFS function is called about $$$n+m$$$ times. Normally, each call results in $$$\mathcal{O}(1)$$$ operations. However, note that each call copies the graph data, requiring significantly more time ($$$\mathcal{O}(n+m)$$$ per call).

bool visited[200005];

void dfs(vector<vector<int>> &g, int n, int m, int node)
{
    if (visited[node]) return;
    visited[node]=true;
    for (auto nxt : g[node]) dfs(g,n,m,nxt);
}

We pass by reference. Note that $$$&g$$$ is an address. Instead of copying the entire graph, we simply refer to it. One reference costs $$$O(1)$$$ time, leading to the optimal total time complexity of $$$\mathcal{O}(n+m)$$$.

#include <bits/stdc++.h>

#define FAST ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);cerr.tie(0)
#define xx first
#define yy second

using namespace std;
long long int typedef li;
pair<int,int> typedef pii;
const int mod = 998244353;
//const int mod = 1000000007;







//Note to self: Check for overflow

int calc(vector<int> &a, vector<int> &b, int n)
{
    sort(a.begin(),a.end());
    sort(b.begin(),b.end());
    long long res=1;
    for (int i=0;i<n;i++) (res*=min(a[i],b[i]))%=mod;
    return res;
}

main()
{
    FAST;

    int t; cin>>t;
    while (t--)
    {
        int n,q; cin>>n>>q;
        vector<int> a(n),b(n);
        for (auto &it : a) cin>>it;
        for (auto &it : b) cin>>it;

        cout<<calc(a,b,n)<<" ";

        while (q--)
        {
            int o,x; cin>>o>>x; x--;
            if (o==1) a[x]++;
            if (o==2) b[x]++;
            cout<<calc(a,b,n)<<" ";
        }

        cout<<"\n";
    }
}

//Note to self: Check for overflow

Because I passed the vectors by reference. In the $$$\texttt{calc}$$$ function, I sorted the two arrays. It caused them to re-index. Since I passed them by reference, their shuffling remained outside the function. Later, this caused problems since performing the queries on $$$a[x]$$$ and $$$b[x]$$$ is incorrect because $$$x$$$ might not be the correct index anymore.

Not pass by reference. I did not need to save time or memory, since the purpose of my code was to test the idea's correctness, not the implementation's running time.