The Fourth Dimension Space

枯叶北风寒，忽然年以残，念往昔，语默心酸。二十光阴无一物，韶光贱，寐难安； 不畏形影单，道途阻且慢，哪曲折，如渡飞湍。斩浪劈波酬壮志，同把酒，共言欢！ -如梦令

ACRUSH-楼天成 百度之星答题源码

初赛一
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

#define _MAXL 2000000 

void GetN(char *s,long long &N) 
{ 
    N=0; 
    for (int i=0;s[i];i++) 
        N=N*10+(s[i]-48); 
} 
void print_bigint(long long n) 
{ 
    if (n>=10) 
        print_bigint(n/10); 
    printf("%d",int(n%10)); 
} 
void Solve(long long N) 
{ 
    bool find_answer=false; 
    long long L,T,A1,k; 
    for (L=2;L<=_MAXL && L*(L-1)/2<N;L++); 
    for (L--;L>=2;L--) 
    { 
        T=L*(L-1)/2; 
        if (N>T && (N-T)%L==0) 
        { 
            find_answer=true; 
            A1=(N-T)/L; 
            for (k=0;k<L;k++) 
            { 
                if (k>0) 
                    printf(" "); 
                print_bigint(A1+k); 
            } 
            printf("\n"); 
        } 
    } 
    if (!find_answer) 
        printf("NONE\n"); 
} 
int main(int argc,char *arg[]) 
{ 
    long long N; 
    GetN(arg[1],N); 
    Solve(N); 
    return 0; 
} 


初赛二
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 

//buf 
const int bufsize=128*1024; 
int bufL,bufP; 
char buf[bufsize]; 
//segments 
const int maxn=1000005; 
int n; 
unsigned int A[maxn],B[maxn]; 
//sort 
const int countsize=65536; 
int arcA[maxn],arcB[maxn],turnB[maxn]; 
int count[countsize],tmp[maxn]; 
//solve 
unsigned int maxB[maxn],maxL[maxn]; 

void swap(unsigned int &a,unsigned int &b) 
{ 
    unsigned int t=a; 
    a=b; 
    b=t; 
} 
char readchar() 
{ 
    if (bufL==bufP) 
    { 
        bufL=read(0,buf,bufsize); 
        if (bufL==0) 
            return 0; 
        bufP=0; 
    } 
    return buf[bufP++]; 
}     
bool readnumber(unsigned int &v) 
{ 
    char c; 
    do{ 
        c=readchar(); 
        if (c==0) 
            return false; 
    }while (c<'0' || c>'9'); 
    for (v=0;c>='0' && c<='9';c=readchar()) 
        v=v*10+(c-48); 
    return true; 
} 
void init() 
{ 
    bufL=bufP=0; 
    for (n=0;readnumber(A[n+1]) && readnumber(B[n+1]);) 
    { 
        n++; 
        if (A[n]>B[n]) 
            swap(A[n],B[n]); 
    } 
} 
void count_sort(unsigned int A[],int arc[]) 
{ 
    int i; 
    //lower bit 
    memset(count,0,sizeof(count)); 
    for (i=1;i<=n;i++) 
        count[A[i]&65535]++; 
    for (i=1;i<countsize;i++) 
        count[i]+=count[i-1]; 
    for (i=n;i>=1;i--) 
        tmp[count[A[i]&65535]--]=i; 
    //higher bit 
    memset(count,0,sizeof(count)); 
    for (i=1;i<=n;i++) 
        count[A[i]>>16]++; 
    for (i=1;i<countsize;i++) 
        count[i]+=count[i-1]; 
    for (i=n;i>=1;i--) 
        arc[tmp[i]]=(count[A[tmp[i]]>>16]--); 
} 
void preprocess() 
{ 
    count_sort(A,arcA); 
    count_sort(B,arcB); 
    for (int i=1;i<=n;i++) 
        turnB[arcB[i]]=i; 
} 
void checkmax(double &answer,unsigned int S,unsigned int T) 
{ 
    if (S>T) 
        return; 
    double t=double(T)-double(S)+1; 
    if (t>answer) 
        answer=t; 
} 
#define lowbit(n) (((n)^((n)-1))&(n)) 
void add_maxB(int i,unsigned int v) 
{ 
    for (;i<=n;i+=lowbit(i)) 
        if (v>maxB[i]) 
            maxB[i]=v; 
} 
void add_maxL(int i,unsigned int v) 
{ 
    i=n+1-i; 
    for (;i<=n;i+=lowbit(i)) 
        if (v>maxL[i]) 
            maxL[i]=v; 
} 
unsigned int get_maxB(int i) 
{ 
    unsigned int t=0; 
    for (;i>0;i-=lowbit(i)) 
        if (maxB[i]>t) 
            t=maxB[i]; 
    return t; 
} 
unsigned int get_maxL(int i) 
{ 
    i=n+1-i; 
    unsigned int t=0; 
    for (;i>0;i-=lowbit(i)) 
        if (maxL[i]>t) 
            t=maxL[i]; 
    return t; 
} 
void solve() 
{ 
    double answer=0; 
    memset(maxB,0,sizeof(maxB)); 
    memset(maxL,0,sizeof(maxL)); 
    for (int T=1;T<=n;T++) 
    { 
        int i=turnB[T],LA=arcA[i]; 
        checkmax(answer,A[i],get_maxB(LA)); 
        checkmax(answer,1   ,get_maxL(LA)); 
        add_maxB(LA,B[i]); 
        add_maxL(LA,B[i]-A[i]+1); 
    } 
    printf("%0.0lf\n",answer); 
} 
int main() 
{ 
    freopen("input.txt","r",stdin); 
    init(); 
    preprocess(); 
    solve(); 
    return 0; 
} 


初赛三：
#include <stdio.h> 
#include <string.h> 
#include <unistd.h> 

//buf 
const int bufsize=128*1024; 
int bufL,bufP; 
char buf[bufsize]; 

char readchar() 
{ 
    if (bufL==bufP) 
    { 
        bufL=read(0,buf,bufsize); 
        if (bufL==0) 
            return 0; 
        bufP=0; 
    } 
    return buf[bufP++]; 
} 

//data 
const int max_strlen=512*1024; 
const int hashsize=30011; 

struct THashPoint 
{ 
    char *s1,*s2; 
    THashPoint *next; 
}; 
char lines[max_strlen],*s1,*s2; 
FILE *f; 
THashPoint *Hash[hashsize]; 

bool read_str() 
{ 
    lines[0]=0; 
    fgets(lines,max_strlen,f); 
    if (strlen(lines)>0 && lines[strlen(lines)-1]=='\n') 
        lines[strlen(lines)-1]=0; 
    if (strlen(lines)<3) 
        return false; 
    for (int i=0;lines[i];i++) 
        if (lines[i]==' ' || lines[i]=='\t') 
        { 
            s1=lines; 
            s2=lines+i+1; 
            lines[i]=0; 
            return true; 
        } 
        return false; 
} 
int HashTable_function(char *s) 
{ 
    int address=strlen(s)%hashsize; 
    for (int i=0;s[i];i++) 
        address=(address*107+s[i]+128)%hashsize; 
    return address; 
} 
void HashTable_Insert() 
{ 
    int address=HashTable_function(s1); 
    THashPoint *p; 
    for (p=Hash[address];p!=NULL;p=p->next) 
        if (strcmp(p->s1,s1)==0) 
        { 
            p->s2=new char[strlen(s2)+1]; 
            strcpy(p->s2,s2); 
            return; 
        } 
        p=new THashPoint; 
        p->s1=new char[strlen(s1)+1]; 
        p->s2=new char[strlen(s2)+1]; 
        strcpy(p->s1,s1); 
        strcpy(p->s2,s2); 
        p->next=Hash[address]; 
        Hash[address]=p; 
} 
void Print(char *s) 
{ 
    int address=HashTable_function(s); 
    THashPoint *p; 
    for (p=Hash[address];p!=NULL;p=p->next) 
        if (strcmp(p->s1,s1)==0) 
        { 
            printf("%s",p->s2); 
            return; 
        } 
        printf("%s",s); 
} 
void Init_HashTable() 
{ 
    f=fopen("dict.txt","r"); 
    while (read_str()) 
        HashTable_Insert(); 
    fclose(f); 
} 
int main() 
{ 
    Init_HashTable(); 
    //Main 
    freopen("text.txt","r",stdin); 
    bufL=bufP=0; 
    int L=0; 
    for (char c;(c=readchar())!=0;) 
        if (c==' ' || c=='\t' || c=='\n') 
        { 
            lines[L]=0; 
            Print(lines); 
            printf("%c",c); 
            L=0; 
        } 
        else 
            lines[L++]=c; 
    lines[L]=0; 
    Print(lines); 
    return 0; 
}     


初赛四：
#include <stdio.h> 
#include <string.h> 
#include <unistd.h> 

const int bufsize=128*1024; 
int bufL; 
char buf[bufsize]; 

struct THashPoint 
{ 
    char *s; 
    int c; 
    THashPoint *next; 
}; 
int MemoryID=0; 
THashPoint **Hash,*Memory; 

char *text; 
int L,HashSize,minC; 

void ReadFile() 
{ 
    text=new char[bufsize+5]; 
    L=0; 
    int textL=bufsize+5; 
    while (1) 
    { 
        bufL=read(0,buf,bufsize); 
        if (bufL==0) 
            break; 
        while (L+bufL>=textL) 
        { 
            char *t_text=text; 
            textL*=2; 
            text=new char[textL]; 
            memcpy(text,t_text,L); 
        } 
        memcpy(text+L,buf,bufL); 
        L+=bufL; 
    } 
    text[L]=0; 
} 
bool Prime(int n) 
{ 
    for (int i=2;i*i<=n;i++) 
        if (n%i==0) 
            return false; 
    return true; 
} 
void Prepare() 
{ 
    int N=0,i; 
    for (i=0;i<L;i++) 
        if (text[i]==' ' || text[i]=='\t' || text[i]=='\n') 
            text[i]=0; 
    for (i=0;i<L;i++) 
        if ((i==0 || text[i-1]==0) && text[i]!=0) 
            N++; 
    for (HashSize=N*2+10;!Prime(HashSize);HashSize++); 
    Hash=new THashPoint* [HashSize]; 
    for (i=0;i<HashSize;i++) 
        Hash[i]=NULL; 
    MemoryID=0; 
    Memory=new THashPoint[N+10]; 
} 
int HashTable_function(char *s) 
{ 
    int address=strlen(s)%HashSize; 
    for (int i=0;s[i];i++) 
        address=(address*137+s[i]+128)%HashSize; 
    return address; 
} 
void HashTable_Insert(char *s) 
{ 
    int address=HashTable_function(s); 
    THashPoint *p; 
    for (p=Hash[address];p!=NULL;p=p->next) 
        if (strcmp(p->s,s)==0) 
        { 
            p->c++; 
            return; 
        } 
        p=&Memory[MemoryID++]; 
        p->s=s; 
        p->c=1; 
        p->next=Hash[address]; 
        Hash[address]=p; 
} 
bool Print(char *s) 
{ 
    int address=HashTable_function(s); 
    THashPoint *p; 
    for (p=Hash[address];p!=NULL;p=p->next) 
        if (strcmp(p->s,s)==0 && p->c==minC) 
            return false; 
    return true; 
} 
void Solve() 
{ 
    int i; 
    for (i=0;i<L;i++) 
        if ((i==0 || text[i-1]==0) && text[i]!=0) 
            HashTable_Insert(text+i); 
    minC=2000000000; 
    for (i=0;i<MemoryID;i++) 
        if (Memory[i].c<minC) 
            minC=Memory[i].c; 
    bool first=true; 
    for (i=0;i<L;i++) 
        if ((i==0 || text[i-1]==0) && text[i]!=0 && Print(text+i)) 
        { 
            if (!first) 
                printf(" "); 
            first=false; 
            printf("%s",text+i); 
        } 
} 
int main() 
{ 
    freopen("corpus.txt","r",stdin); 
    ReadFile(); 
    Prepare(); 
    Solve(); 
    return 0; 
}     



网上决赛一：
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 

const int maxn2=100000+5; 
const int maxn=5000+5; 
const int max_outputL=10000000; 
const int oo=1000000000; 
//buf 
const int bufsize=256*1024; 
int bufL,bufP; 
char buf[bufsize]; 
char *bufp; 
//输入图 
int n2,indexID[maxn2],indexP[maxn2]; 
int deg2[maxn2],*G2[maxn2],*W2[maxn2]; 
//并查集 
int father[maxn2],sortlist[maxn2]; 
//新建图 
int n,listM[maxn],G[maxn][maxn],tG[maxn][maxn]; 
//输出 
int outputL=0; 
char outputs[max_outputL]; 
//最小树形图 
int prev[maxn],tmpG[maxn]; 
bool saved[maxn],incycle[maxn]; 
//深度优先搜索 
int DFS_count; 
bool DFS_vis[maxn]; 

//输入数据函数 
char readchar() 
{ 
    if (bufL==bufP) 
    { 
        bufL=read(0,buf,bufsize); 
        if (bufL==0) 
            return 0; 
        bufP=0; 
    } 
    return buf[bufP++]; 
}     
bool Valid(char c) 
{ 
    return (c!=' ') && (c!='\t') && (c!='\n') && (c!=0); 
} 
bool ReadString(char *s) 
{ 
    while (1) 
    { 
        if (*bufp==0) 
            return false; 
        if (Valid(*bufp)) 
            break; 
        bufp++; 
    } 
    int L=0; 
    for (;Valid(*bufp);bufp++) 
        s[L++]=*bufp; 
    s[L]=0; 
    return true; 
} 
void ReadLine() 
{ 
    char c; 
    while (1) 
    { 
        int L=0; 
        while (1) 
        { 
            c=readchar(); 
            if (c=='\n' || c==0) 
                break; 
            outputs[L++]=c; 
        } 
        outputs[L]=0; 
        if (L>=2) 
            break; 
    } 
} 
//输出数据函数 
void push_char(char c) 
{ 
    outputs[outputL++]=c; 
} 
void write(int v) 
{ 
    if (v>=10) 
        write(v/10); 
    push_char('0'+v%10); 
} 
//并查集函数 
int getfather(int v)  
{ 
    return (father[v]==0)?v:(father[v]=getfather(father[v])); 
} 
void merge(int i,int j) 
{ 
    i=getfather(i); 
    j=getfather(j); 
    if (i<j) 
        father[j]=i; 
    if (j<i) 
        father[i]=j; 
} 

void ReadData() 
{ 
    int i,j,v,k; 
    char s[100]; 
    ReadLine(); 
    bufp=outputs; 
    ReadString(s); 
    for (n2=0;ReadString(s);) 
    { 
        sscanf(s,"%d",&v); 
        indexID[++n2]=v; 
    } 
    int maxd=0; 
    for (i=1;i<=n2;i++) 
    { 
        ReadLine(); 
        bufp=outputs; 
        ReadString(s); 
        sscanf(s,"%d",&v); 
        for (k=1;indexID[k]!=v;k++); 
        //calc deg[k] 
        deg2[k]=0; 
        for (;ReadString(s);) 
        { 
            if (s[0]=='/') 
                continue; 
            sscanf(s,"%d",&v); 
            if (v>0) 
                deg2[k]++; 
        } 
        if (deg2[k]>maxd) 
            maxd=deg2[k]; 
        G2[k]=new int[deg2[k]+5]; 
        W2[k]=new int[deg2[k]+5]; 
        //read again 
        bufp=outputs; 
        ReadString(s); 
        deg2[k]=0; 
        for (j=1;j<=n2;j++) 
        { 
            ReadString(s); 
            if (s[0]=='/') 
                continue; 
            sscanf(s,"%d",&v); 
            if (v>0) 
            { 
                G2[k][++deg2[k]]=j; 
                W2[k][deg2[k]]=v; 
            } 
        } 
    } 
} 
void DFS(int v) 
{ 
    if (DFS_vis[v]) 
        return; 
    DFS_vis[v]=true; 
    DFS_count++; 
    for (int i=1;i<=n;i++) 
        if (G[v][i]<oo) 
            DFS(i); 
} 
bool process() 
{ 
    if (n==1) 
    { 
        write(listM[1]); 
        push_char(' '); 
        write(0); 
        push_char('\n'); 
        return true; 
    } 
    int i,j,u,v; 
    int answer=oo,total; 
    for (int srcp=1;srcp<=n;srcp++) 
    { 
        for (u=1;u<=n;u++) 
            for (v=1;v<=n;v++) 
                G[u][v]=tG[u][v]; 
        DFS_count=0; 
        for (i=1;i<=n;i++) 
            DFS_vis[i]=false; 
        DFS(srcp); 
        if (DFS_count<n) 
            continue; 
        total=oo; 
        for (i=1;i<=n;i++) 
            if (G[i][srcp]<total) 
                total=G[i][srcp]; 
        if (total==oo) 
            continue; 
        for (i=1;i<=n;i++) 
        { 
            prev[i]=0; 
            saved[i]=true; 
        } 
        while (1) 
        { 
            int minCost=oo; 
            for (i=1;i<=n;i++) if(i!=srcp && prev[i]==0 && saved[i]) 
                for (j=1;j<=n;j++) if (saved[j]) 
                    if (G[j][i]<minCost) 
                    { 
                        minCost=G[j][i]; 
                        u=j; 
                        v=i; 
                    } 
                    if (minCost==oo) 
                        break; 
                    total+=minCost; 
                    //insert edge (u,v) 
                    prev[v]=u; 
                    for (i=u;prev[i]!=0 && i!=v;i=prev[i]); 
                    if (prev[i]==0) 
                        continue; 
                    //cycle 
                    for (i=1;i<=n;i++) 
                        incycle[i]=false; 
                    incycle[v]=true; 
                    for (i=u;i!=v;i=prev[i]) 
                        incycle[i]=true; 
                    for (i=1;i<=n;i++) 
                        tmpG[i]=oo; 
                    for (i=1;i<=n;i++) if (saved[i] && !incycle[i]) 
                        for (j=1;j<=n;j++) if (saved[j] && incycle[j]) 
                        { 
                            if (G[j][i]<G[v][i]) 
                                G[v][i]=G[j][i]; 
                            if (G[i][j]<oo) 
                            { 
                                int t=G[i][j]-G[prev[j]][j]; 
                                if (t<tmpG[i]) 
                                    tmpG[i]=t; 
                            } 
                        } 
                        for (i=1;i<=n;i++) if (saved[i] && !incycle[i]) 
                            if (prev[i]>0 && incycle[prev[i]]) 
                                prev[i]=v; 
                        prev[v]=0; 
                        for (i=u;i!=v;i=prev[i])  
                            saved[i]=false; 
                        for (i=1;i<=n;i++) 
                            G[i][v]=tmpG[i]; 
        } 
        if (total<answer) 
            answer=total; 
    } 
    if (answer==oo) 
        return false; 
    for (i=1;i<=n;i++) 
    { 
        write(listM[i]); 
        push_char(' '); 
    } 
    write(answer); 
    push_char('\n'); 
    return true; 
} 
int qsort_comp(const void *p1,const void *p2) 
{ 
    int t1=*(int *)p1,t2=*(int *)p2; 
    if (getfather(t1)!=getfather(t2)) 
        return getfather(t1)-getfather(t2); 
    return t1-t2; 
} 
void solve() 
{ 
    int i,j,u,v; 
    memset(father,0,sizeof(father)); 
    for (i=1;i<=n2;i++) 
        for (j=1;j<=deg2[i];j++) 
            merge(i,G2[i][j]); 
    for (i=1;i<=n2;i++) 
        sortlist[i]=i; 
    qsort(sortlist+1,n2,sizeof(int),qsort_comp); 
    for (i=1;i<=n2;i=j) 
        if (father[sortlist[i]]==0) 
        { 
            for (j=i;j<=n2 && getfather(sortlist[i])==getfather(sortlist[j]);j++); 
            n=j-i; 
            if (n>maxn-5) 
            { 
                printf("NONE\n"); 
                return; 
            } 
            for (v=i;v<j;v++) 
            { 
                listM[v-i+1]=indexID[sortlist[v]]; 
                indexP[sortlist[v]]=v-i+1; 
            } 
            for (u=1;u<=n;u++) 
                for (v=1;v<=n;v++) 
                    tG[u][v]=oo; 
            for (u=i;u<j;u++) 
                for (v=1;v<=deg2[sortlist[u]];v++) 
                    tG[indexP[sortlist[u]]][indexP[G2[sortlist[u]][v]]]=W2[sortlist[u]][v]; 
            if (!process()) 
            { 
                printf("NONE\n"); 
                return; 
            } 
        } 
        outputs[outputL]=0; 
        printf("%s",outputs); 
} 
int main() 
{ 
    freopen("sites.txt","r",stdin); 
    bufP=bufL=0; 
    ReadData(); 
    solve(); 
    return 0; 
} 




网上决赛二：
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 

const char *rules_filename="rules.txt"; 
const char *facts_filename="facts.txt"; 
const int hashsize=1000007; 
const int maxm=100000+5; 
const int maxn=1000000+5; 
const int bufsize=256*1024; 

//读入 
int bufL,bufP; 
char buf[bufsize]; 
char str[1000000]; 
//读入函数 
char readchar() 
{ 
    if (bufL==bufP) 
    { 
        bufL=read(0,buf,bufsize); 
        bufP=0; 
        if (bufL==0) 
            return 0; 
    } 
    return buf[bufP++]; 
} 
bool valid(char c) 
{ 
    return (c!=0 && c!='\t' && c!='\n' && c!=' ' && c!='&' && c!='-' && c!='>'); 
} 
bool readstring(char *s) 
{ 
    int L=0; 
    char c; 
    do{ 
        c=readchar(); 
        if (c==0) 
            return false; 
        if (L==0 && c=='>') 
            s[L++]=c; 
    }while (!valid©); 
    for (;valid©;c=readchar()) 
        s[L++]=c; 
    s[L]=0; 
    return true; 
} 
//目标变量 
int goal; 
//规则集合 
struct TRule 
{ 
    char *rule_name; 
    int n,*C,A; 
}; 
int m; 
TRule Rules[maxm]; 
int _n,_C[1000000]; 
int left[maxm],nlist,list[maxm]; 
//命题集合 
struct Tpoint 
{ 
    int v; 
    Tpoint *next; 
}; 
int n; 
bool fact[maxn],need_prove[maxn],org_fact[maxn]; 
Tpoint *Appear[maxn]; 
//HashTable,用于保存(命题名)->(int)的映射 
struct THashTable 
{ 
    char *var; 
    int id; 
    THashTable *next; 
}; 
THashTable *Hash[hashsize]; 

int find(char *s) 
{ 
    int L=strlen(s); 
    int address=L; 
    for (int i=0;s[i];i++) 
        address=(address*101+s[i])%hashsize; 
    THashTable *p; 
    for (p=Hash[address];p!=NULL;p=p->next) 
        if (strcmp(p->var,s)==0) 
            return p->id; 
    p=new THashTable; 
    p->next=Hash[address]; 
    Hash[address]=p; 
    p->var=new char[L+2]; 
    strcpy(p->var,s); 
    p->id=(++n); 
    return n; 
} 
void insert_Point(int v,int pp) 
{ 
    Tpoint *p=new Tpoint; 
    p->v=pp; 
    p->next=Appear[v]; 
    Appear[v]=p; 
} 
void read_rules() 
{ 
    m=0; 
    while (1) 
    { 
        if (!readstring(str)) 
            return; 
        m++; 
        Rules[m].rule_name=new char[strlen(str)+2]; 
        strcpy(Rules[m].rule_name,str); 
        _n=0; 
        while (1) 
        { 
            readstring(str); 
            if (str[0]=='>') 
            { 
                Rules[m].A=find(str+1); 
                break; 
            } 
            else 
                _C[++_n]=find(str); 
        } 
        Rules[m].C=new int[_n+2]; 
        Rules[m].n=_n; 
        for (int k=1;k<=_n;k++) 
        { 
            Rules[m].C[k]=_C[k]; 
            insert_Point(_C[k],m); 
        } 
    } 
} 
void read_facts() 
{ 
    memset(fact,false,sizeof(fact)); 
    FILE *f=fopen(facts_filename,"r"); 
    while (fscanf(f,"%s",&str)!=-1) 
        fact[find(str)]=true; 
    fclose(f); 
} 
void TPsort() 
{ 
    int i,j,k; 
    Tpoint *p; 
    nlist=0; 
    for (i=1;i<=m;i++) 
    { 
        left[i]=0; 
        for (j=1;j<=Rules[i].n;j++) 
            if (!fact[Rules[i].C[j]]) 
                left[i]++; 
        if (left[i]==0) 
            list[++nlist]=i; 
    } 
    for (i=1;i<=nlist;i++) 
    { 
        k=Rules[list[i]].A; 
        if (fact[k]) 
            continue; 
        fact[k]=true; 
        for (p=Appear[k];p!=NULL;p=p->next) 
        { 
            left[p->v]--; 
            if (left[p->v]==0) 
                list[++nlist]=p->v; 
        } 
    } 
} 
void solve_data() 
{ 
    for (int i=1;i<=nlist;i++) 
    { 
        printf(" %s",Rules[list[i]].rule_name); 
        if (Rules[list[i]].A==goal) 
            break; 
    } 
    printf("\n"); 
} 
void solve_goal() 
{ 
    int i,k; 
    memset(need_prove,false,sizeof(need_prove)); 
    need_prove[goal]=true; 
    for (i=1;i<=nlist;i++) 
        if (Rules[list[i]].A==goal) 
            break; 
    for (;i>0;i--) 
        if (need_prove[Rules[list[i]].A] && !org_fact[Rules[list[i]].A]) 
        { 
            printf(" %s",Rules[list[i]].rule_name); 
            for (k=1;k<=Rules[list[i]].n;k++) 
                need_prove[Rules[list[i]].C[k]]=true; 
        } 
        printf("\n"); 
} 
int main(int argc,char *arg[]) 
{ 
    if (argc!=3) 
    { 
        printf("Argument Error!\n"); 
        return 0; 
    } 
    freopen(rules_filename,"r",stdin); 
    bufP=bufL=n=0; 
    memset(Hash,0,sizeof(Hash)); 
    memset(Appear,0,sizeof(Appear)); 
    goal=find(arg[2]); 
    read_rules(); 
    read_facts(); 
    memcpy(org_fact,fact,sizeof(fact)); 
    if (fact[goal]) 
    { 
        printf("TRUE %s\n",arg[1]); 
        return 0; 
    } 
    TPsort(); 
    if (!fact[goal]) 
        printf("UNCERTAIN\n"); 
    else 
    { 
        printf("TRUE %s",arg[1]); 
        if (strcmp(arg[1],"data")==0) 
            solve_data(); 
        else 
            solve_goal(); 
    } 
    return 0; 
} 



总决赛：
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

const int hashsize=70001; 
const int maxnode=50000; 
const int maxp=40; 
const int ten[]={1,10,100,1000,10000,100000,1000000,10000000,100000000}; 
const int C[]={2,3,2,3,4,3,2,3,2}; 
const int EP[][4]={{1,3,0,0},{0,2,4,0},{1,5,0,0},{0,4,6,0},{1,3,5,7},{2,4,8,0},{3,7,0,0},{4,6,8,0},{5,7,0,0}}; 

struct Tlist 
{ 
    int data,d; 
    Tlist *next; 
}; 
struct Thashpoint 
{ 
    int data; 
    Thashpoint *next; 
}; 
//Memory 
int ID; 
Tlist listM[maxnode],*q; 
Thashpoint hashM[maxnode],*p; 
//data 
int src,dest; 
//heap 
Tlist *head[maxp],*expand[maxp],*lp1,*lp2; 
//Hash 
Thashpoint *hash[hashsize]; 
//expand 
int nowp,A[9],arcT[9],dist[9][9],b,depth,swap[9][9]; 
int data,G,newdata,newG; 
bool find_answer; 

void readdata(const char *filename,int &data) 
{ 
    int i,v; 
    FILE *f=fopen(filename,"r"); 
    data=0; 
    for (i=0;i<9;i++) 
    { 
        fscanf(f,"%d",&v); 
        data=data+v*ten[i]; 
    } 
    fclose(f); 
} 
bool check_noanswer() 
{ 
    int p[9],i,b1,b2; 
    bool vis[9]; 
    for (i=0;i<9;i++) 
        p[i]=arcT[src/ten[i]%10]; 
    for (b1=0; src/ten[b1]%10!=0;b1++); 
    for (b2=0;dest/ten[b2]%10!=0;b2++); 
    int countP=0; 
    memset(vis,false,sizeof(vis)); 
    for (i=0;i<9;i++) 
        if (!vis[i]) 
        { 
            countP++; 
            for (int k=i;!vis[k];k=p[k]) 
                vis[k]=true; 
        } 
        return (countP-dist[b1][b2])%2==0; 
} 
void preprocess() 
{ 
    ID=0; 
    find_answer=false; 
    memset(hash,0,sizeof(hash)); 
    memset(head,0,sizeof(head)); 
    memset(expand,0,sizeof(expand)); 
    for (int k=0;k<9;k++) 
        arcT[dest/ten[k]%10]=k; 
    for (int u=0;u<9;u++) 
        for (int v=0;v<9;v++) 
        { 
            dist[u][v]=abs(u/3-v/3)+abs(u%3-v%3); 
            swap[u][v]=ten[u]-ten[v]; 
        } 
} 
void addnode() 
{ 
    if (newdata==dest) 
    { 
        printf("%d\n",depth); 
        find_answer=true; 
        return; 
    } 
    int address=newdata%hashsize; 
    for (p=hash[address];p!=NULL;p=p->next) 
        if (p->data==newdata) 
            return; 
    if (ID==maxnode) 
        return; 
    p=&hashM[ID]; 
    p->data=newdata; 
    p->next=hash[address]; 
    hash[address]=p; 
    q=&listM[ID]; 
    ID++; 
    q->data=newdata; 
    q->d=depth; 
    if (newG>=maxp) 
        return; 
    if (newG==nowp) 
    { 
        q->next=expand[depth]; 
        expand[depth]=q; 
    } 
    else 
    { 
        q->next=head[newG]; 
        head[newG]=q; 
    } 
} 
void solve() 
{ 
    nowp=-1; 
    newdata=src; 
    newG=0; 
    for (int k=0;k<9;k++) 
        if (src/ten[k]%10!=0) 
            newG+=dist[arcT[src/ten[k]%10]][k]; 
    depth=0; 
    addnode(); 
    if (find_answer) 
        return; 
    for (int p=0;p<maxp;p++) if (head[p]!=NULL) 
    { 
        nowp=p; 
        for (lp1=head[p];lp1!=NULL;lp1=lp2) 
        { 
            lp2=lp1->next; 
            lp1->next=expand[lp1->d]; 
            expand[lp1->d]=lp1; 
        } 
        for (int d=0;d<=p;d++) 
            for (;expand[d]!=NULL;) 
            { 
                data=expand[d]->data; 
                G=p-expand[d]->d; 
                depth=expand[d]->d+1; 
                expand[d]->d=-2; 
                expand[d]=expand[d]->next; 
                for (b=0;data/ten[b]%10!=0;b++); 
                for (int v=0;v<C[b];v++) 
                { 
                    int u=EP[b][v]; 
                    int c=data/ten[u]%10; 
                    newdata=data+swap[b][u]*c; 
                    c=arcT[c]; 
                    newG=depth+G-dist[c][u]+dist[c][b]; 
                    addnode(); 
                    if (find_answer) 
                        return; 
                } 
            } 
    } 
    printf("-1\n"); 
} 
int main() 
{ 
    readdata("start.txt",src); 
    readdata("goal.txt",dest); 
    preprocess(); 
    if (check_noanswer()) 
        printf("-1\n"); 
    else 
        solve(); 
    return 0; 
} 


posted on 2009-03-01 20:51 abilitytao 阅读(6594) 评论(4)  编辑 收藏 引用

评论

# re: ACRUSH-楼天成 百度之星答题源码 2009-03-02 15:16 梦在天涯

强！支持！  回复  更多评论   

# re: ACRUSH-楼天成 百度之星答题源码 2009-03-02 16:45 haskell

你是楼天成？？？  回复  更多评论   

# re: ACRUSH-楼天成 百度之星答题源码 2009-03-05 22:41 cdy20

总决赛哪个代码不知道哪种题？
题目呢  回复  更多评论   

# re: ACRUSH-楼天成 百度之星答题源码 2009-03-06 22:26 abilitytao

@cdy20
没有...  回复  更多评论   


只有注册用户登录后才能发表评论。
网站导航:   博客园   博客园最新博文   博问   管理