Hdu 3812 Sea Sky (模拟_搜索)-CSDN博客

原文链接：http://blog.csdn.net/woshi250hua/article/details/7614161

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3812

题目大意：给定n个字符对ai,bi，表示ai和bi相连，现在要求求出从“sea”连接到"sky"的一个序列，序列中的字符串出现两次，长度要求最大，并且字典序最小，如果没办达到要求，输出"what a pity“。

解题思路：这题是去年武汉邀请赛的题目，难度中上，在做模拟比赛的时候碰到了这题，当时没敢开，难题猛于虎。赛后为了防止比赛时再被虐花点时间过了这题。刚开始想的时候觉得是图论没思路，但一看到最多的字符串种类为16，有戏。就想着状态dp，状态就三万多个，怎么搞都不超时，又看了一下题目，要求输出字典序最小，顿时泄气，还是要搜索啊，那索性直接搜索再加个强力剪枝什么的过了他。

开始的时候把这些字符串用map转化为节点并建图，建好图写了个十分暴力的深搜，试探性地交了下果然Tle。然后开始想如何剪枝，很常规的有两个：1、如果sea和sky不出现在输入中，那他们怎么连接都连接不到对方，人鬼殊途啊。2、如果sea和sky不在一个连通分支，那他们怎么连接都连接不到对方，不是同一个世界的人啊。这两个显然不能有效地增加效率，加上去再交还是Tle。然后开始找性质，其实剪枝就是要求我们找出题目中的性质，然后把不需要搜索的地方排除掉。本题要求的序列中字符串不能出现两次，那我们从sea节点开始遍历，如果某个节点不经过sky就能遍历，那说明在最后的深搜中可以到达，如果某些节点必须要通过sky节点，那说明这个节点必然没办法到达（可以到达的话sky节点就要经过两次），这些符合条件的节点组成几何Set1？同理，可以从end也找一次也能找到一个集合Set2。这样就得到了两个集合Set1和Set2，他们的交集就是可能出现在最后的序列中的节点。记录这个集合大小result，表示所有序列的最大长度，如果第一次碰到序列长度等于result，他就是最后的解（前提是字典序最小，这个在建图前对每个字符串排个序就可以保证）。

举个例子: a <-->sea b<---> sea sky<--> b sky<-->d 那Set1集合为sea a b sky,Set2集合为sky b d sea，他们的交集是sea sky b，只有这三个字符串可能出现在最后的序列中。

测试数据：

10
8
sea a
sea b
sea c
c d
a sky
sky c
sky b
d sky

7
sea pure
pure air
air white
sky white
pure holy
holy white
sky holy

2
sea love
sky love

3
sea blue
blue green
fuckfuck white

代码：

    #include <stdio.h>  
    #include <string.h>  
    #include <string>  
    #include <map>  
    #include <vector>  
    #include <algorithm>  
    using namespace std;  
    #define MIN 30  
    #define MAX 300  
    #define max(a,b) (a)>(b)?(a):(b)  
      
      
    struct node {  
      
        char s1[MAX],s2[MAX];  
    }ver[MAX];  
      
    vector<int> maze[MIN];  
    map<string,int> mmap;  
      
    int n,result,flag,maybe[MIN][4];  
    int beg,end,maxx,tot,fa[MIN],vis[MIN];  
    char str[MAX][MIN],ans[MAX][MIN];  
      
      
    int cmp(node a,node b) {  
    //排序用到的比较函数  
        if (strcmp(a.s1,b.s1) == 0)  
            return strcmp(a.s2,b.s2) < 0;  
        else return strcmp(a.s1,b.s1) < 0;  
    }  
    int GetFa(int x) {  
    //获取父亲节点  
        int y = fa[x];  
        while (y != fa[y]) y = fa[y];  
        return y;  
    }  
    void UnionSet(int u,int v) {  
    //并查集的并操作  
        int fau = GetFa(u);  
        int fav = GetFa(v);  
        if (fav != fau) fa[fau] =fav;  
    }  
    void Create_Graph() {  
    //建好一张有序的图  
        int i,u,v;  
        for (i = 1; i <= 2 * n; ++i) {  
      
            string tps1 = string(ver[i].s1);  
            string tps2 = string(ver[i].s2);  
            if (mmap.find(tps1) == mmap.end())  
                u = ++tot,mmap[tps1] = u;  
            else u = mmap[tps1];  
            if (mmap.find(tps2) == mmap.end())  
                v = ++tot,mmap[tps2] = v;  
            else v = mmap[tps2];  
            maze[u].push_back(v);  
      
              
            UnionSet(u,v);  
            strcpy(str[u],ver[i].s1);  
            strcpy(str[v],ver[i].s2);  
            if (tps1 == "sea") beg = u;  
            else if (tps2 == "sea") beg = v;  
            if (tps1 == "sky") end = u;  
            else if (tps2 == "sky") end = v;  
        }  
    }  
      
      
    void LookConn(int k,int flag,int in) {  
    //寻找从beg开始到不经过end到达的点或者从end开始不经过beg能到达的点  
        vis[k] = 1,maybe[k][in] = 1;  
        if (k == flag) return;  
        for (int i = 0; i < maze[k].size(); ++i) {  
      
            int v = maze[k][i];  
            if (vis[v]) continue;  
            LookConn(v,flag,in);  
        }  
    }  
    void Dfs(int k,int cnt,int *vis,int *arr) {  
    //普通深搜，加个剪枝而已  
        vis[k] = 1,arr[cnt] = k;  
        if (k == end) {  
      
            if (cnt > maxx) {  
      
                maxx = cnt;  
                for (int i = 1; i <= maxx; ++i)  
                    strcpy(ans[i],str[arr[i]]);  
            }  
            if (maxx == result) flag = 1;//剪枝，result是能够到达的最多数量，因为有序，此解必是最优  
            return;  
        }  
      
      
        for (int i = 0; i < maze[k].size(); ++i) {  
      
            int v = maze[k][i];  
            if (vis[v] == 0 && maybe[v][2] == 1) {  
      
                vis[v] = 1;  
                Dfs(v,cnt+1,vis,arr);  
                if (flag) return;  
                vis[v] = 0;  
            }  
        }  
    }  
    int Solve_1A(){  
      
        int i,j,k,arr[MIN];  
      
        //寻找可能到达的点  
        memset(maybe,0,sizeof(maybe));  
        memset(vis,0,sizeof(vis));  
        LookConn(beg,end,0);  
        memset(vis,0,sizeof(vis));  
        LookConn(end,beg,1);  
        result = 0;  
        for (i = 1; i <= tot; ++i) {  
      
            if (maybe[i][1] && maybe[i][0])  
                    maybe[i][2] = 1;  
            if (maybe[i][2]) result++;  
        }  
      
        //赋初值，并从beg开始深搜  
        memset(vis,0,sizeof(vis));  
        Dfs(beg,1,vis,arr);  
        return maxx;  
    }  
      
      
      
    int main()  
    {  
        int u,v,tpu,tpk;  
        int i,j,k,t,cas = 0;  
      
      
        scanf("%d",&t);  
        while (t--) {  
      
            scanf("%d",&n);  
            mmap.clear();  
            flag = maxx = 0;  
            tot = beg = end = 0;  
            for (i = 1; i < MIN; ++i)  
                maze[i].clear(),fa[i] = i;  
      
      
            for (i = 1; i <= n; ++i) {  
            //无向处理成有向  
                scanf("%s%s",ver[i].s1,ver[i].s2);  
                strcpy(ver[i+n].s1,ver[i].s2);  
                strcpy(ver[i+n].s2,ver[i].s1);  
            }  
      
            //对节点根据字典序排序，把同一个节点出来的归类  
            sort(ver+1,ver+1+2*n,cmp);  
            Create_Graph();  
              
            //输出解  
            printf("Case %d: ",++cas);  
            if (end == 0 || beg == 0   
                || GetFa(beg) != GetFa(end))  
                printf("what a pity\n");  
            else {  
                  
                int maxx = Solve_1A();  
                for (i = 1; i <= maxx; ++i)  
                    printf(i == maxx ? "%s\n" : "%s ",ans[i]);  
            }  
        }  
    }

本文ZeroClock原创，但可以转载，因为我们是兄弟。