【UVa 12402】 Parallel Missions

题目链接

一个搜索题，和HDOJ的DNA那题类似，不过数据范围大了点。给一些序列，让你求一个最短的序列，使这个序列包含所有子串，这题只多确定了第一个字符。

开始算错了状态数，敲了个和DNA一样的BFS，RE，后来看了好半天才发现少算了一个0，悲剧的状态都开不下了。之后发现有一个条件，说答案不超过20位，就越看越像IDA*了，虽然以前DNA那题的IDA*效率不是很高，但这题那么像也只好敲了。

敲好后果断超时，调整了很多次A*函数也没能A掉，后来加了一个要RP的哈希，1.5s水过。

今天又试着用A*写了一遍，竟然1A了，1.3s，优化了一下1s，实在优化不动了，跪舔跪舔。别人有100+ms的代码，等以后power up了再来挑战

   

#include<cstdio>
#include<cstring>
using namespace std;

int maze[10][8];
int cap[10];
int n;

int dep;
int ans[22];

int ht[10000020];
int val[10000020];

inline int p(int pos, int x){
    return (pos&(7<<(x*3)))>>(x*3); 
} 

bool dfs(int d, int pos){
    
    int h = 0, th = 0;
    bool col[15]={false};
    for(int i=0;i<n;i++){
        int tp=p(pos,i); 
        if(cap[i]-tp>th) th= cap[i]-tp;
        for(int j=tp;j<cap[i];j++){
            if(col[maze[i][j]]) continue;
            col[maze[i][j]]=true;
            h++;
        }
    }
    if(th>h) h=th;
    
    if(h+d>dep) return false;
    if(h==0) return true;
    
    for(int i=0;i<n;i++){
        int tp=p(pos,i); 
        if(cap[i]==tp) continue;
        int c = maze[i][tp];
        bool flag=true; 
        for(int j=0;j<i;j++){
            int ttp=p(pos,j); 
            if(ttp>=cap[j]) continue; 
            if(maze[j][ttp]==c){
                flag = false;
                break; 
            }
        } 
        if(!flag) continue;
        int tpos=pos; 
        for(int j=i;j<n;j++){
            int ttp=p(pos,j);
            if(ttp>=cap[j]) continue; 
            if(maze[j][ttp]==c) tpos+=(1<<(j*3));
        }
        int th = tpos%10000007;
        if(ht[th]==dep&&val[th]<=d) continue;
        ht[th] = dep;
        val[th] = d;
        ans[d] = c;
        if(dfs(d+1,tpos)) return true;
    }
    return false;
}

int main(){
    while(~scanf("%d",&n)){
        memset(ht, -1, sizeof(ht));
        memset(val, -1, sizeof(val));
        
        memset(maze, -1, sizeof(maze));
        for(int i=0;i<n;i++){
            scanf("%d",&cap[i]);
            for(int j=0;j<cap[i];j++){
                scanf("%d",&maze[i][j]);
            }
        }
        int k;
        scanf("%d", &k);
        int pos=0; 
        for(int i=0;i<n;i++){
            pos += ((maze[i][0]==k)<<(i*3));
        }
        
        dep=0;
        while(true){
            if(dfs(0,pos)) break;
            dep++;
        }
        
        printf("%d", k);
        for(int i=0;i<dep;i++){
            printf(" %d", ans[i]);
        }
        puts("");
    }
}

  

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map> 
using namespace std;

int n; 
int k[12]; 
int c[12][8]; 

inline int p(int pos, int x){
    return (pos&(7<<(x*3)))>>(x*3); 
} 

struct S{
    int t, h;
    unsigned pos;
    int path[22];
    
    S(){}
    S(int _t, unsigned _pos, int _path[]){
        t=_t;
        pos=_pos; 
        //memcpy(pos, _pos, sizeof(pos));
        memcpy(path, _path, sizeof(path)); 
        geth(); 
    }
    
    S(const S& s){
        t=s.t;
        h=s.h;
        pos=s.pos; 
        //memcpy(pos, s.pos, sizeof(pos));
        memcpy(path, s.path, sizeof(path)); 
    } 
    
    void geth(){
//        h=0; 
//        for(int i=0;i<n;i++){
//            h=max(h, k[i]-pos[i]); 
//        }

        h=0; 
        int th = 0;
        bool fuck[15]={false};
        for(int i=0;i<n;i++){
            if(k[i]-p(pos,i)>th) th= k[i]-p(pos,i);
            for(int j=p(pos,i);j<k[i];j++){
                if(fuck[c[i][j]]) continue;
                fuck[c[i][j]]=true;
                h++;
            }
        }
        if(th>h) h=th;
    } 
    
    friend bool operator< (const S& a, const S& b){
        if(a.t+a.h!=b.t+b.h) return a.t+a.h>b.t+b.h;
        return a.h>b.h; 
        //return a.t+a.h>b.t+b.h; 
    } 
    
    
    void show(){
        printf("%d %d\n", t, h); 
        printf("== "); 
        for(int i=0;i<t;i++){
            if(i) putchar(' ');
            printf("%d", path[i]); 
        } puts(""); 
        printf("~~ "); 
        for(int i=0;i<n;i++){
            if(i) putchar(' ');
            printf("%d", p(pos,i)); 
        } puts(""); 
        puts("================"); 
    } 
}; 

bool vis[10000011]; 

void bfs(int ss){
    memset(vis,false,sizeof(vis)); 
    
    priority_queue<S> que;
    int _path[22], _pos=0; 
    for(int i=0;i<n;i++){
         _pos |= ((c[i][0]==ss)<<(i*3));
    } 
    _path[0]=ss;
    que.push(S(1, _pos, _path));
    
    while(!que.empty()){
        S u(que.top());
        que.pop(); 
        
        if(u.h==0){
            for(int i=0;i<u.t;i++){
                if(i) putchar(' ');
                printf("%d", u.path[i]); 
            } puts(""); 
            return; 
        } 
        
                
        unsigned ht=u.pos%10000007;
        if(vis[ht]) continue;
        vis[ht] = true; 
        
        for(int i=0;i<n;i++){
            if(p(u.pos,i)==k[i]) continue;
            bool flag=false; 
            for(int j=0;j<i;j++){
                if(p(u.pos,j)==k[j]) continue;
                if(c[j][p(u.pos,j)]==c[i][p(u.pos,i)]){
                    flag = true;
                    break; 
                } 
            } 
            if(flag) continue; 
            S v(u); 
            for(int j=i;j<n;j++){
                if(c[j][p(u.pos,j)]==c[i][p(u.pos,i)]){
                    v.pos+=(1<<(j*3)); 
                } 
            } 
            v.path[v.t]=c[i][p(u.pos,i)];
            v.t++;
            v.geth();
            que.push(v); 
        } 
    } 
} 

int main(){
    while(~scanf("%d",&n)){
        for(int i=0;i<n;i++){
            scanf("%d", &k[i]);
            for(int j=0;j<k[i];j++){
                scanf("%d", &c[i][j]); 
            } 
        }
        int ss;
        scanf("%d", &ss); 
        bfs(ss); 
    } 
}