C++博客-古月残辉-文章分类-Template

SPFA的堆栈实现

古月残辉 — Thu, 23 Apr 2009 11:50:00 GMT

算法简介
         SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种优化，减少了不必要的冗余计算。它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边，但判断负回路不方便。
         值得注意的是，得到可行解后，可以看成新的约束：xi-xj<=d[i]-d[j]，即d[i]为xi-x0的最大值。由此可以看出，SPFA和Bellman-Ford算法解决差分约束系统问题时，实际上是把约束条件强化了，使得满足任意约束条件的值都能构造出一个完整的解。同样的，当约束方程为>=时，求出的xi-xj>=d[i]-d[j]，故d[i]为xi-x0的最小值。理解后灵活运用，差分约束问题就比较容易解决了。(这里设x0为源点)

算法流程
         SPFA对Bellman-Ford算法优化的关键之处在于意识到：只有那些在前一遍松弛中改变了距离估计值的点，才可能引起他们的邻接点的距离估计值的改变。因此，算法大致流程是用堆栈或队列存放被成功松弛的顶点。初始时，源点s入队。当队列不为空时，取出栈顶/队首顶点，对它的邻接点进行松弛。如果某个邻接点松弛成功，且该邻接点不在堆栈/队列中，则将其入栈/队。经过有限次的松弛操作后，堆栈/队列将为空，算法结束。

int N,M;    //实际的顶点数和边数
struct Edge{
    int to, cost;
    Edge* next;
}edges[MAXM+1];        //MAXM为最大边数
Edge* linklist[MAXN+1]={0};        //MAXN为最大顶点数
void SPFA( Edge* linklist[], int dist[], int source ){    //参数分别为边的临接表、距离、源点，堆栈实现
    bool bInQ[MAXN+1]={0};        //判断点是否在堆栈中
    int stack[MAXN+1]={0}, top=0;    //保存活动结点
    for( int i= 1; i<= N; i++ )
        dist[i]= INF;
    dist[source]= 0;
    stack[top++]= source;
    while( top ){
        int cur= stack[--top];
        Edge* q= linklist[cur];
        bInQ[cur]= 0;
        while( q ){
            if( dist[q->to]> dist[cur]+q->cost ){
                dist[q->to]= dist[cur]+q->cost;
                if( !bInQ[q->to] )
                    stack[top++]= q->to;
                bInQ[q->to]=1;
            }
            q=q->next;
        }
    }
}

古月残辉 2009-04-23 19:50 发表评论

并查集

古月残辉 — Tue, 17 Mar 2009 14:16:00 GMT

class UnionNS{
public:
    int maxV;
    int* p;
    UnionNS( int v ){
        maxV= v;
        p= new int[maxV];
        memset(p,-1,sizeof(int)*maxV);
    }
    // 求根运算：
    int root( int i ){
        int j, r;
        for( r= i; p[r]>= 0 ; r= p[r] );
        for( ; i!= r; i= j ){
            j= p[i];
            p[i]= r; // 路径压缩
        }
        return r;
    }
    // 判断等价
    bool equal( int i, int j ){
        return root(i)==root(j);
    }
    // 求集合规模
    int size( int i ){
        return  -p[root(i)];
    }
    // 合并
    void merge( int i, int j ){
        i= root(i); j= root(j);
        if ( i== j )  return ;
        if ( p[i]< p[j] ){ // 树状合并
            p[i]+= p[j];
            p[j]= i;
        }
        else{
            p[j]+= p[i];
            p[i]= j;
        }
    }
};

古月残辉 2009-03-17 22:16 发表评论

Farey序列

古月残辉 — Tue, 17 Mar 2009 14:15:00 GMT

#define farey_Max 100001
int farey_Size;        //Fn的n
__int64 farey_Total;    //farey序列元素个数
int farey[farey_Max][2];    //保存farey序列
//构造Farey序列
void MakeFarey( int x1, int y1, int x2, int y2 ){    //初始为0,1,1,1
    if( y1+ y2> farey_Size )    return;
    MakeFarey( x1, y1, x1+x2, y1+y2 );
    farey[farey_Total][0]= x1+x2;
    farey[farey_Total][1]= y1+y2;
    farey_Total++;
    MakeFarey( x1+x2, y1+y2, x2, y2 );
}
__int64 phy[farey_Max];    //欧拉函数
__int64 tab[farey_Max];    //|Fn|大小
//计算farey序列的元素个数
void FareyCount(){
    int prime[200], size= 0;
    bool comp[1000];
    memset(comp,0,sizeof(comp));
    phy[1] = 1;
    tab[1] = 0;
    prime[0] = 2;
    int i, j, k;
    //求素数
    for( i= 2; i< 1000; i++ )
        if( !comp[i] )
            for( j= i+ i; j< 1000; j+= i )
                comp[j]= 1;
    for( i= 2; i< 1000; i++ )
        if( !comp[i] )
            prime[size++] = i;
    //求欧拉函数
    for( j= 2; j< farey_Max; j++ ){
        for( i= 0; i< size ;i++ ){
            if( j% prime[i]== 0 ){
                k= j/ prime[i];
                if( k%prime[i]== 0 )
                    phy[j]= phy[k]* prime[i];
                else
                    phy[j]= phy[k]* (prime[i]-1);
                break;
            }
        }
        if( i== size )
            phy[j]= j- 1;
    }
    //求序列个数
    for( i= 2; i< farey_Max; i++ )
        tab[i]= tab[i-1]+ phy[i];

}

古月残辉 2009-03-17 22:15 发表评论

Trie树

古月残辉 — Tue, 17 Mar 2009 14:14:00 GMT

可以申请静态的结点数组，则Delete操作只要把数组的指针置为首地址/*内*/

#define keyNum 26
#define maxSize 10000
struct TrieNode{
    TrieNode *link[keyNum];
    int num[keyNum];
    bool iselement[keyNum];
    void init(){
        memset(link,0,sizeof(link));
        memset(num,0,sizeof(num));
        memset(iselement,0,sizeof(iselement));
    }
};
/*
TrieNode tn[maxSize];
TrieNode *cnt= tn;
*/
class TrieTree{
public:
    TrieNode* root;
    TrieTree(){
        root= 0;
    }
    void Init(){
        root= new TrieNode;
        /*root= cnt++;*/
        root->init();
    }
    bool Search( char *x ){
        if( *x==0 )    return false;
        TrieNode* current= root;
        while( *x ){
            if( current->link[*x-'a'] )
                current= current->link[*x-'a'];
            else break;
            x++;
        }
        if( current->iselement[*x-'a'] || *x==0 )
            return true;
        else
            return false;
    }
    void Insert( char x[] ){
        TrieNode *current= root;
        int i= 1;
        while( x[i] ){
            if( current->link[x[i-1]-'a']==NULL ){
                current->link[x[i-1]-'a']= new TrieNode;
                /*current->link[x[i-1]-'a']= cnt++;*/
                (current->link[x[i-1]-'a'])->init();
            }
            current= current->link[x[i-1]-'a'];
            i++;
        }
        (current->num[x[i-1]-'a'])++;
        current->iselement[x[i-1]-'a']= true;
    }
    void Delete( TrieNode* t ){
        int i;
        for( i= 0; i<keyNum; i++ )
            if( t->link[i] )    Delete(t->link[i]);
        memset( t->num,0,sizeof(t->num) );
        memset( t->iselement,0,sizeof(t->iselement) );
        delete(t);
        /*cnt= tn;*/
    }
};

古月残辉 2009-03-17 22:14 发表评论

常用小代码(持续更新)

古月残辉 — Fri, 13 Mar 2009 05:02:00 GMT

摘要: 1）求最大公约数：int Gcd( int a, int b ) int Gcd( int a, int b ){ //a, b为两个输入的数，返回最大公约数 while( b... 阅读全文

古月残辉 2009-03-13 13:02 发表评论