[luogu8291]学术社区

对所有消息建图，其中$(x,y)$的边权为当$x$的下一条消息为$y$时的收益

具体的，图中包含以下两类边（边权为$1$）：

• 对于楼上消息，假设其提到的网友为$s$，其向$s$发出的消息连边
• 对于楼下消息，假设其提到的网友为$s$，$s$发出的消息向其连边

另外，特殊性质$C$中的情况会产生重边，此时该边边权为$2$

此时，问题即选择边的子集，满足每个点出入度均不超过$1$，并最大化边权和

结论1：对于重边$(x,y)$，存在一种最优方案选择该边

任取一组最优解，若未选择$(x,y)$，则分类讨论：

• 若其中$x$的出边存在且边权为$2$，则交换$y$和该出边端点（两者完全相同）
• 类似的，若$y$的入边存在且边权为$2$，则交换$x$和该入边端点
• 否则，直接删除$x$的出边和$y$的入边，并加入$(x,y)$，显然不劣

根据此结论，可以将图中$x$的出边和$y$的入边均删除，并将最终答案$+2$

重复此过程，最终图中所有边的边权均为$1$，问题也即求最小路径覆盖

结论2：将该图视作DAG求最小路径覆盖，答案不变

对于通常的有向图，该做法问题在于可能选择一个简单环

注意到简单环中总包含非学术消息（学术消息间无边），不妨假设包含楼上消息

楼上消息的入边（另一个端点）必然也为楼上消息，以此类推整个环均为楼上消息

此时，任取图中某个消息，在该处断开并插入到对应的学术消息前即可

重复上述过程，最终可得一组不包含简单环的方案，即得证

根据此结论，并简单优化建边，由于二分图至多增广$\sqrt{m}$次，时间复杂度为$O(m\sqrt{m})$

建边时使用vector会比邻接表快很多，可能是出边顺序的问题

#include<bits/stdc++.h>
using namespace std;
#define N 80000
#define M 1000000
#define ull unsigned long long
int t,n,m,a[N],b[N],c[N];ull s1,s2,s3,id[N];
int V,E,it[M],d[M];queue<int>q;struct Data{int to,len,rev;};vector<Data>e[M];
int ans,pos[N],vis[N],pre[N],nex[N];vector<int>vl,vr;map<int,vector<int> >mat1[N],mat2[N];
int change(char c){
    if ((c>='A')&&(c<='Z'))return c-'A'+1;
    if ((c>='a')&&(c<='z'))return c-'a'+27;
    if (c=='_')return 53;
    if (c=='?')return 54;
    if (c=='!')return 55;
    return (c=='.' ? 56 : 0);
}
ull read(){
    ull x=0;int c=change(getchar());
    while (!c)c=change(getchar());
    while (c)x=x*57+c,c=change(getchar());
    return x;
}
void add(int x,int y,int z){
    e[x].push_back(Data{y,z,(int)e[y].size()});
    e[y].push_back(Data{x,0,(int)e[x].size()-1});
}
bool bfs(){
    for(int i=1;i<=V;i++)d[i]=-1;
    q.push(0);
    while (!q.empty()){
        int k=q.front();q.pop();
        for(Data i:e[k])
            if ((i.len)&&(d[i.to]<0))d[i.to]=d[k]+1,q.push(i.to);
    }
    return d[V]>=0;
}
int dfs(int k,int s){
    if (k==V)return s;
    int ans=0;
    for(int &i=it[k];i<e[k].size();i++)
        if ((e[k][i].len)&&(d[e[k][i].to]==d[k]+1)){
            int p=dfs(e[k][i].to,min(s,e[k][i].len));
            e[k][i].len-=p,e[e[k][i].to][e[k][i].rev].len+=p,s-=p,ans+=p;
            if (!s)return ans;
        }
    return ans;
}
int dinic(){
    int ans=0;
    while (bfs()){
        ans+=dfs(0,0x3f3f3f3f);
        for(int i=0;i<=V;i++)it[i]=0;
    }
    return ans;
}
void link(int x,int y){
    if (nex[x])pre[nex[x]]=0;
    if (pre[y])nex[pre[y]]=0;
    nex[x]=(x ? y : 0),pre[y]=(y ? x : 0);
}
int main(){
    scanf("%d",&t);
    while (t--){
        scanf("%d%d",&n,&m);
        V=(m+n<<1)+1,E=ans=0;
        for(int i=0;i<=V;i++)it[i]=0,e[i].clear();
        for(int i=1;i<=m;i++)vis[i]=pre[i]=nex[i]=0;
        for(int i=1;i<=n;i++)mat1[i].clear(),mat2[i].clear();
        for(int i=1;i<=n;i++)id[i]=read();
        sort(id+1,id+n+1);
        for(int i=1;i<=m;i++){
            s1=read(),s2=read(),s3=read();
            a[i]=lower_bound(id+1,id+n+1,s1)-id;
            b[i]=lower_bound(id+1,id+n+1,s2)-id;
            if ((b[i]>n)||(id[b[i]]!=s2))b[i]=c[i]=0;
            else c[i]=(s3==23305962750LL ? 2 : (s3==75721020011865LL));
            if (!c[i])pos[a[i]]=i;
            if (c[i]==1){
                if (mat2[b[i]][a[i]].empty())mat1[a[i]][b[i]].push_back(i);
                else{
                    int j=mat2[b[i]][a[i]].back();
                    mat2[b[i]][a[i]].pop_back();
                    ans+=2,link(i,j),vis[i]=vis[j]=1;
                }
            }
            if (c[i]==2){
                if (mat1[b[i]][a[i]].empty())mat2[a[i]][b[i]].push_back(i);
                else{
                    int j=mat1[b[i]][a[i]].back();
                    mat1[b[i]][a[i]].pop_back();
                    ans+=2,link(j,i),vis[i]=vis[j]=1;
                }
            }
        }
        for(int i=1;i<=m;i++){
            add(0,i,1),add(i+m,V,1);
            if ((!vis[i])||(c[i]!=1))add(i,a[i]+(m<<1),1);
            if ((!vis[i])||(c[i]!=2))add(a[i]+(m<<1)+n,i+m,1);
            if ((!vis[i])&&(c[i]==1))add(i,b[i]+(m<<1)+n,1);
            if ((!vis[i])&&(c[i]==2))add(b[i]+(m<<1),i+m,1);
        }
        ans+=dinic(),printf("%d\n",ans);
        for(int i=1;i<=n;i++){
            for(Data j:e[i+(m<<1)+n])e[i+(m<<1)].push_back(j);
            for(Data j:e[i+(m<<1)]){
                if ((j.to<=m)&&(j.len)){
                    if (vr.empty())vl.push_back(j.to);
                    else link(j.to,vr.back()),vr.pop_back();
                }
                if ((j.to>m)&&(!j.len)){
                    if (vl.empty())vr.push_back(j.to-m);
                    else link(vl.back(),j.to-m),vl.pop_back();
                }
            }
        }
        for(int i=1;i<=m;i++)vis[i]=0;
        for(int i=1;i<=m;i++)
            if (!vis[i]){
                int j=i;
                while (!vis[j])vis[j]=1,j=nex[j];
                if (j==i){
                    if (c[i]==1)j=pre[i],link(pre[pos[a[i]]],i),link(j,pos[a[i]]);
                    else j=nex[i],link(i,nex[pos[a[i]]]),link(pos[a[i]],j);
                }
            }
        for(int i=1;i<=m;i++)
            if (!pre[i]){
                for(int j=i;j;j=nex[j])printf("%d ",j);
            }
        printf("\n");
    }
    return 0;
}