H-Modify Minieye杯第十五届华中科技大学程序设计邀请赛现场赛

题面见 https://ac.nowcoder.com/acm/contest/700#question

题目大意是有n个单词，有k条替换规则（单向替换），每个单词会有一个元音度（单词里元音的个数）和长度，现在希望利用替换规则（每个规则可使用无限次或不用）将每个单词替换成元音度值最小的单词，如果有多个单词元音度同等最小，那么取长度最小的单词。最后输出替换后的n个单词的元音度值之和与长度之和。

单纯每个点暴力搜，无疑会有爆复杂度的风险 1e5*1e5 ，如果记录搜过的点之后不搜，也会有在一个强连通分量里最早的点能搜到最优解，而后来的点无法get到这个最有解。

 

于是我们可以用Tarjan求scc后缩点，然后在缩点之后的分量图开始DFS。因为这个分量图是绝对无环的图，所以可以在不重复搜点下得到最优解。

比赛时 替换最优解的判断写错了，昏了头把长度的比较搞错。然后此题还有一个坑点，就是开始给的n个单词中可能会有重复，不能直接由string映射至点号。

 

比赛时代码修改后的通过版本：

#include<bits/stdc++.h>

using namespace std;
#define IsVow(i) ((i)=='a'||(i)=='e'||(i)=='i'||(i)=='o'||(i)=='u')
typedef long long ll;

const int maxn=300000+5;
struct Edge{
    int from,to;
    int nxt;
};
struct word{
    int vow,len;
}voc[maxn], syno[maxn];;
bool vis[maxn];
int head[maxn],tot;
Edge edges[maxn];
map<string , int > dict;
string ori[maxn];
int DFN[maxn],LOW[maxn],STACK[maxn],Belong[maxn];
int scc,dfs_no,top;
bool Instack[maxn];
vector< vector< int > > G(maxn, vector<int>() );

void addedge(int u,int v){
    edges[tot].from=u;
    edges[tot].to=v;
    edges[tot].nxt=head[u];
    head[u]=tot++;
}

word make_word(string & s){
    int cnt=0;
    word ans;
    ans.len=(int) s.size();
    for(auto const& i:s)
        if(IsVow(i)) cnt++;
    ans.vow=cnt;
    return ans;
}

void Tarjan(int u){
    LOW[u]=DFN[u]=++dfs_no;
    STACK[++top]=u;
    Instack[u]=true;
    for(int i=head[u];i!=-1;i=edges[i].nxt){
        int v=edges[i].to;
        if(!DFN[v]){
            Tarjan(v);
            LOW[u]=min(LOW[u],LOW[v]);
        }
        else if(Instack[v])
            LOW[u]=min(LOW[u],DFN[v]);
    }
    if(LOW[u]==DFN[u]){
        scc++;
        syno[scc]=(word){500005,500005};
        while(STACK[top]!=u){
            int v=STACK[top];
            if(voc[v].vow < syno[scc].vow)
            {                      
                syno[scc].vow=voc[v].vow;
                syno[scc].len=voc[v].len;
            }
            else if( syno[scc].vow == voc[v].vow) 
                syno[scc].len=min(syno[scc].len,voc[v].len);
            

            Instack[STACK[top]]=false;
            Belong[STACK[top--]]=scc;

        }
        Instack[u]=false;
        Belong[u]=scc;
        top--;
                    if(voc[u].vow < syno[scc].vow)
            {                      
                syno[scc].vow=voc[u].vow;
                syno[scc].len=voc[u].len;
            }
            else if( syno[scc].vow == voc[u].vow) 
                syno[scc].len=min(syno[scc].len,voc[u].len);
                }
}

void DFS(int ind){
    //cout<<ind<<":"<<syno[ind].vow<<" , "<<syno[ind].len<<endl;
    if(vis[ind]){
        return ;
    }
    vis[ind]=true;

    for(int i=0;i<G[ind].size();++i){
        int nxind=G[ind][i];
        DFS(nxind);
        if(syno[nxind].vow < syno[ind].vow)
        {                      
            syno[ind].vow=syno[nxind].vow;
            syno[ind].len=syno[nxind].len;
        }
        else if( syno[nxind].vow == syno[ind].vow) 
                syno[ind].len=min(syno[ind].len,syno[nxind].len);
        }
}

int main(){
    ios::sync_with_stdio(false);cin.tie(0);
    memset(head,-1,sizeof(head));
    tot=0;
    int n,k;
    cin>>n;
    int TOT=0;
    for(int i=1;i<=n;++i){
        string tmp;
        cin>>tmp;
        ori[i]=tmp;
        if(dict.count(tmp)==0){
        dict[tmp]=++TOT;
        voc[dict[tmp]]=make_word(tmp);
        }
    }
    cin>>k;
    //cout<<"N:K:"<<n<<k<<endl;
    for(int i=0;i<k;++i){
        string frm,to;
        cin>>frm>>to;
        if(dict.count(frm)==0) {dict[frm]=++TOT;voc[dict[frm]]=make_word(frm);}
        if(dict.count(to)==0)  {dict[to]=++TOT;voc[dict[to]]=make_word(to);}
        addedge(dict[frm],dict[to]);
    }
    scc=0;
    for(int i=1;i<=n;++i)
        if(!DFN[i])
            Tarjan(i);
    /*
    for(int i=1;i<=scc;++i)
        syno[i]=(word){500000+5,5000000+5};
        */
    for(int i=0;i<tot;++i){
        int u=edges[i].from,v=edges[i].to;
        if(Belong[u]!=Belong[v]){
            G[Belong[u]].push_back(Belong[v]);
        }
    }
    
    /*
    for(int i=1;i<=TOT;++i){
        int ind=Belong[i];
        if(syno[ind].vow > voc[i].vow)
        {
            syno[ind].vow= voc[i].vow;
            syno[ind].len= voc[i].len;
        }
        else if(syno[ind].vow == voc[i].len)
            syno[ind].len= min(syno[ind].len,voc[i].len); 
    }
    */
    ll X=0,Y=0;
    //for(int i=1;i<=scc;++i)
    //    cout<<"scc "<<i<<" : "<<syno[i].vow<<" and "<<syno[i].len<<endl;
    
    for(int i=1;i<=scc;++i){
        int ans1,ans2;
        ans1=syno[i].vow;
        ans2=syno[i].len;
        DFS(i);
    }
    
    for(int i=1;i<=n;++i){
        int ans1, ans2;
        ans1=syno[Belong[dict[ori[i]]]].vow;
        ans2=syno[Belong[dict[ori[i]]]].len;
        //DFS(Belong[i],ans1,ans2);
        //cout<<Belong[i]<<endl;
        X+=1ll*ans1;
        Y+=1ll*ans2;
    }
    cout<<X<<' '<<Y<<endl;
    return 0;
}

 

后来看到别人代码，发现可以定义一个类，把优解与劣解的比较重载为<

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

#define IsVow(x) ((x)=='a'||(x)=='e'||(x)=='i'||(x)=='o'||(x)=='u')
typedef long long ll;
const int maxn=3e5+5;
struct word{
    ll  vow;
    ll  len;
    word(){}
    word(ll _v,ll _l):vow(_v),len(_l){}
    bool operator< (const word & tmp)const{
        if(vow==tmp.vow) return len<tmp.len;
        return vow<tmp.vow;
    }
    word operator+ (const word& tmp)const{
        return word(vow+tmp.vow,len+tmp.len);
    }
};
word voc[maxn],syno[maxn];

struct Edge{
    int from;
    int to;
    int nxt;
}edges[maxn];
map<string ,int > dict;
string strcash[100000+5];
int head[maxn],tot;

int DFN[maxn],LOW[maxn],STK[maxn],BLG[maxn],top=0,scc=0,dfs_no=0;
bool InSTK[maxn];
vector< vector< int > > G(maxn+1,vector<int>() );
int vis[maxn];
void Tarjan(int u){
    LOW[u]=DFN[u]=++dfs_no;
    STK[top++]=u;
    InSTK[u]=true;
    for(int i=head[u];i!=-1;i=edges[i].nxt){
        int v=edges[i].to;
        if(!DFN[v]){
            Tarjan(v);
            LOW[u]=min(LOW[u],LOW[v]);
        }
        else if(InSTK[v])
            LOW[u]=min(LOW[u],DFN[v]);
    }
    if(DFN[u]==LOW[u]){
        int v;
        scc++;
        syno[scc]=word(500000+5,500000+5);
        do{
            v=STK[--top];
            InSTK[v]=false;
            BLG[v]=scc;
            if(voc[v]<syno[scc])
                syno[scc]=voc[v];
        }while(u!=v);
    }
}

word make_word(string X){
    ll _l=1ll*X.length();
    ll _v=0;
    for(auto const & i:X){
        if(IsVow(i)) _v++;
    }
    return word(_v,_l);
}

void AddEdge(int u,int v){
    edges[tot].from=u;
    edges[tot].to=v;
    edges[tot].nxt=head[u];
    head[u]=tot++;
}

void DFS(int u){
    if(vis[u]) return;
    vis[u]=true;
    for(auto v:G[u]){
        DFS(v);
        if(syno[v]<syno[u]) syno[u]=syno[v];
    }
}

int main(){
    ios::sync_with_stdio(false);cin.tie(0);
    int _n,_k;
    int vtx_no=0;
    cin>>_n;
    for(int i=0;i<_n;++i){
        string tmp;cin>>tmp;
        strcash[i]=tmp;
        if(dict.count(tmp)==0){
            dict[tmp]=++vtx_no;
            voc[vtx_no]=make_word(tmp);
        }
    }
    cin>>_k;
    memset(head,-1,sizeof(head));
    tot=0;
    for(int i=0;i<_k;++i){
        string frm,to;cin>>frm>>to;
        if(dict.count(frm)==0){
            dict[frm]=++vtx_no;
            voc[vtx_no]=make_word(frm);
        }
        if(dict.count(to)==0){
            dict[to]=++vtx_no;
            voc[vtx_no]=make_word(to);
        }
        AddEdge(dict[frm],dict[to]);
    }

    top=0,scc=0,dfs_no=0;
    for(int i=1;i<=vtx_no;++i){
        if(!DFN[i]) Tarjan(i);
    }
    for(int i=0;i<tot;++i){
        int u=edges[i].from,v=edges[i].to;
        u=BLG[u];
        v=BLG[v];
        if(u!=v) G[u].push_back(v);
    }
    //for(int i=1;i<=vtx_no;++i) cout<<"voc "<<i<<" : "<<voc[i].vow<<" , "<<voc[i].len<<endl;
    //for(int i=1;i<=vtx_no;++i) cout<<strcash[i]<<":"<<i<<" belongs to "<<BLG[i]<<endl;
    memset(vis,false,sizeof(vis));
    //for(int i=1;i<=scc;++i) cout<<syno[i].vow<<" "<<syno[i].len<<endl;
    for(int i=1;i<=scc;++i){
        DFS(i);
    }
    //puts("after DFS:");for(int i=1;i<=scc;++i) cout<<syno[i].vow<<" "<<syno[i].len<<endl;
    ll __X=0,__Y=0;
    for(int i=0;i<_n;++i){
        int ob=BLG[dict[strcash[i]]];
        __X+=syno[ob].vow;
        __Y+=syno[ob].len;
    }
    cout<<__X<<" "<<__Y<<endl;
    return 0;
}

 

转念一想，所谓点之间的优劣比较不就是先比元音数，元音数同则比长度吗？这不就是 STL里pair 的比较吗！？要啥结构体，要啥重载< ！？

在算导上求scc那部分，有一个定理，有向图G=<V,E>的强连通分量与其逆图~G=<V,~E>的强连通分量是重合的。（逆图，，，沉思，，，

想一想，如果不缩点，在求解搜点时从每个点搜到其最优解点的路径是一条单向路径，同一个scc内的点能到的最优解是相同的，不同的scc也可能到相同的优解，它们的终点是相同的，终点相同我们可以做逆图！！！也就是从这个解按反向搜到可以到达这个解的所有点。

在建图时，有向边方向取逆，搜索时从最优的点（用间接排序）开始搜，如此只用一遍DFS。

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

#define IsVow(i) ((i)=='a'||(i)=='e'||(i)=='i'||(i)=='o'||(i)=='u')
typedef long long ll;

string strcash[100000+5];

map<string ,int > dict;
pair<ll,ll > word[300000+5];
int word_no=0;

struct Edge{
    int to;
    int nxt;
}edges[200000+5];
int head[300000+5],tot;

int id[300000+5];
bool vis[300000+5];

pair<ll,ll> make_word(string X){
    ll len=X.length();
    ll cnt=0;
    for(const auto  & i:X){
        if(IsVow(i)) cnt++;
    }
    return make_pair(cnt,len);
}

void AddVtx(string X){
    if(dict.count(X)==0){
        dict[X]=++word_no;
        word[word_no]=make_word(X);
    }
}

void AddEdge(int u,int v){
    edges[tot].to=v;
    edges[tot].nxt=head[u];
    head[u]=tot++;
}

bool cmp(int i,int j){
    return word[i]<word[j];
}

void DFS(int u){
    if(vis[u]) return;
    vis[u]=true;
    for(int i=head[u];i!=-1;i=edges[i].nxt){
        int v=edges[i].to;
        //cout<<u<<"->"<<v<<endl;
        if(!vis[v]){
            word[v]=word[u];
            //cout<<"DFS "<<v<<endl;
            DFS(v);
        }
    }
}

int main(){
    ios::sync_with_stdio(false);cin.tie(0);

    memset(head,-1,sizeof(head));
    tot=0;

    int n,k;
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>strcash[i];
        AddVtx(strcash[i]);
    }
    cin>>k;
    for(int i=0;i<k;++i){
        string f,t;cin>>f>>t;
        AddVtx(f);
        AddVtx(t);
        AddEdge(dict[t],dict[f]);// ~G
    }

    for(int i=1;i<=word_no;++i)
        id[i]=i;
    sort(id+1,id+1+word_no,cmp);
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=word_no;++i){
        DFS(id[i]);
    }

    ll X=0,Y=0;
    for(int i=0;i<n;++i){
        int _no=dict[strcash[i]];
        X+=word[_no].first;
        Y+=word[_no].second;
    }
    cout<<X<<" "<<Y<<endl;
    return 0;
}