C++博客-_飞寒の魂器.h-随笔分类-图论

PKU 3164 Command Network 最小树形图

_飞寒 — Sun, 20 Feb 2011 13:05:00 GMT

题意：要求建立司令部到各个欧几里德平面上的节点，给定可建立的顶点对(u,v) = u 可建立单向信道至 v ，求司令部形成对所有节点的指挥需要的最小建设花费。
算法：最小图形树，不解释~

1/*
2Problem: 3164        User: _mTy
3Memory: 872K        Time: 172MS
4Language: C++        Result: Accepted
5
6Source Code
7*/
8#include
9#include
10#include
11#define MAXN 120
12#define inf 1000000000
13typedef double elem_t;
14elem_t edmonds(int n,elem_t mat[][MAXN*2],int* pre);
15int main(){
16    elem_t point[MAXN][2];
17    elem_t mat[MAXN*2][MAXN*2];
18    elem_t res,len;
19    int pre[MAXN];
20    int i,j,n,m,u,v;
21
22    while(scanf("%d%d",&n,&m)!=EOF){
23        for(i=0;i<n;i++) for(j=0;j<n;j++) mat[i][j]=inf;
24        for(i=0;i<n;i++) scanf("%lf%lf",&point[i][0],&point[i][1]);
25        for(i=0;i<m;i++){
26            scanf("%d%d",&u,&v); --u; --v;
27            len = pow(point[u][0]-point[v][0],2)+pow(point[u][1]-point[v][1],2);
28
29            len = sqrt(len);
30            mat[u][v]=len;
31        }
32
33        memset(pre,0,sizeof(pre));
34        pre[0]=-1;
35        res = edmonds(n,mat,pre);
36        if(res<0) printf("poor snoopy\n");
37        else printf("%.2f\n",res);
38    }
39    return 0;
40}
41
42//多源最小树形图,edmonds算法,邻接阵形式,复杂度O(n^3)
43//返回最小生成树的长度,构造失败返回负值
44//传入图的大小n和邻接阵mat,不相邻点边权inf
45//可更改边权的类型,pre[]返回树的构造,用父结点表示
46//传入时pre[]数组清零,用-1标出源点
47
48elem_t edmonds(int n,elem_t mat[][MAXN*2],int* pre){
49    elem_t ret=0;
50    int c[MAXN*2][MAXN*2],l[MAXN*2],p[MAXN*2],m=n,t,i,j,k;
51    for (i=0;i<n;l[i]=i,i++);
52    do{
53        memset(c,0,sizeof(c)),memset(p,0xff,sizeof(p));
54        for (t=m,i=0;i<m;c[i][i]=1,i++);
55        for (i=0;i<t;i++)
56            if (l[i]==i&&pre[i]!=-1){
57                for (j=0;j<m;j++)
58                    if (l[j]==j&&i!=j&&mat[j][i]<inf&&(p[i]==-1||mat[j][i]<mat[p[i]][i]))
59                        p[i]=j;
60                if ((pre[i]=p[i])==-1)
61                    return -1;
62                if (c[i][p[i]]){
63                    for (j=0;j<=m;mat[j][m]=mat[m][j]=inf,j++);
64                    for (k=i;l[k]!=m;l[k]=m,k=p[k])
65                        for (j=0;j<m;j++)
66                            if (l[j]==j){
67                                if (mat[j][k]-mat[p[k]][k]<mat[j][m])
68                                    mat[j][m]=mat[j][k]-mat[p[k]][k];
69                                if (mat[k][j]<mat[m][j])
70                                    mat[m][j]=mat[k][j];
71                            }
72                    c[m][m]=1,l[m]=m,m++;
73                }
74                for (j=0;j<m;j++)
75                    if (c[i][j])
76                        for (k=p[i];k!=-1&&l[k]==k;c[k][j]=1,k=p[k]);
77            }
78    }
79    while (t<m);
80    for (;m-->n;pre[k]=pre[m])
81        for (i=0;i<m;i++)
82            if (l[i]==m){
83                for (j=0;j<m;j++)
84                    if (pre[j]==m&&mat[i][j]==mat[m][j])
85                        pre[j]=i;
86                if (mat[pre[m]][m]==mat[pre[m]][i]-mat[pre[i]][i])
87                    k=i;
88            }
89    for (i=0;i<n;i++)
90        if (pre[i]!=-1)
91            ret+=mat[pre[i]][i];
92    return ret;
93}

_飞寒 2011-02-20 21:05 发表评论

PKU 1679 The Unique MST 次小生成树

_飞寒 — Sun, 20 Feb 2011 05:48:00 GMT

判断一个无向连通图的MST是否唯一，其实本质上就是求是否存在次小树恰好等于MST。
16ms碾过~ 数据弱，不建议用来测试模版，据说有非SST做法，kuskal + LCA + O(E) ？求大神教学……

1/*
2Problem: 1679        User: _mTy
3Memory: 760K        Time: 16MS
4Language: G++        Result: Accepted
5
6Source Code
7*/
8
9#include
10#include
11#include
12#include
13#define N 101
14using namespace std;
15
16struct nod{
17    int u,max;
18};
19int g[N][N];
20int tree[N][N];
21int best[N][N];
22
23int prim(int n,int fa[]);
24
25int main(){
26    int t,n,m;
27    int i,j,u,v,w,t1,total;
28    int fa[N];
29    struct nod tmp,arr[N*N];
30    bool unique,visi[N];
31    scanf("%d",&t);
32    while(t--){
33        scanf("%d%d",&n,&m);
34        for(i=0;i<n;i++) for(j=0;j<n;j++) g[i][j]=0x7fffffff;
35        memset(tree,-1,sizeof(tree));
36        for(i=0;i<m;i++){
37            scanf("%d%d%d",&u,&v,&w);
38            g[u-1][v-1]=g[v-1][u-1]=w;
39        }
40        t1=prim(n,fa);
41        for(i=0;i<n;i++) tree[i][fa[i]]=tree[fa[i]][i]=g[i][fa[i]];
42
43        // bfs
44        total=0;
45        memset(best,-1,sizeof(best));
46        for(i=0;i<n;i++){
47            memset(visi,0,sizeof(visi));
48            arr[total].u=i; arr[total].max=-1;
49            queue<struct nod> _que; _que.push(arr[total]); ++total;
50            visi[i]=1;
51            while(!_que.empty()){
52                tmp = _que.front(); _que.pop();
53                for(v=0;v<n;v++)
54                    if( !visi[v] && tree[tmp.u][v]!=-1 ){
55                       visi[v]=1;
56                       best[i][v]=
57                                (tmp.max<tree[tmp.u][v])?tree[tmp.u][v]:tmp.max;
58                       arr[total].max=best[i][v];
59                       arr[total].u=v;
60                       _que.push(arr[total]);
61                       ++total;
62                    }
63            }
64        }
65        unique = 1;
66        for(i=0;i<n;i++)
67            for(j=i+1;j<n;j++)
68                if( g[i][j]!=0x7fffffff && tree[i][j]==-1 )
69                    if( t1 - best[i][j] + g[i][j] == t1 ) unique = 0;
70
71        if( unique ) printf("%d\n",t1);
72        else printf("Not Unique!\n");
73
74    }
75
76    return 0;
77}

_飞寒 2011-02-20 13:48 发表评论

PKU2337 Catenyms MultiSets+欧拉路

_飞寒 — Tue, 01 Feb 2011 10:57:00 GMT

      题目总体没有难度，做法明确，数据较小。单词做边，首尾字母为点构图。构造output a line giving the lexicographically least compound catenym that contains each dictionary word exactly once 的方法边是每次取边的时候贪心的选择字典序最小的单词。可以用并查集事先判连通和存在性，再求欧拉迹。
      顺便练习了一下多重集MultiSets的使用，用平衡树保持边集的字典序以实现lgn时间内插入和删除，由于set不支持键的修改，只能直接在树中删边。

1#include<cstdio>
2#include<cstring>
3#include<set>
4#include<stack>
5#include<string>
6using namespace std;
7struct nod{
8    char str[22];
9     bool operator < (const nod &a)const{
10         return strcmp(a.str,str)>0;
11     }
12}arr[1111];
13multiset<struct nod> _set[26];
14multiset<struct nod>::iterator it;
15stack<string> _sta;
16int degree[26][2];
17int hash[26];
18
19void solve(int s){
20    int k;
21    string str;
22    while(!_set[s].empty()){
23        it=_set[s].begin();
24        k=(*it).str[strlen((*it).str)-1]-'a';
25        str=(*it).str;
26        _set[s].erase(it);
27        solve(k);
28        _sta.push(str);
29    }
30}
31
32int main(){
33    string ss;
34    bool flag;
35    int _case,n,num,i,s,t;
36    int inNum,outNum,inPos,outPos;
37    scanf("%d",&_case);
38    while(_case--){
39        memset(degree,0,sizeof(degree));
40        memset(hash,0,sizeof(hash));
41        while(!_sta.empty()) _sta.pop();
42        for(i=0;i<26;i++) _set[i].clear();
43
44        scanf("%d",&n); getchar();
45        for(i=0;i<n;i++){
46            gets(arr[i].str);
47            s=arr[i].str[0]-'a';
48            t=arr[i].str[strlen(arr[i].str)-1]-'a';
49            _set[s].insert(arr[i]);
50            hash[s]=hash[t]=1;
51            degree[s][0]++; // out
52            degree[t][1]++; // in
53        }
54        for(flag=true,inNum=outNum=i=0;i<26;i++)
55            if(degree[i][0]!=degree[i][1])
56                if(degree[i][0]==degree[i][1]+1){
57                    outNum++;
58                    outPos=i;
59                }
60                else{
61                    if(degree[i][1]==degree[i][0]+1){
62                        inNum++;
63                        inPos=i;
64                    }
65                    else{
66                        flag=false;
67                        break;
68                    }
69                }
70        if(!flag){ printf("***\n"); continue; }
71        if(inNum==0&&outNum==0){
72            for(i=0;i<26;i++) if(hash[i]) break;
73            solve(i);
74        }
75        if(inNum==1&&outNum==1) solve(outPos);
76
77        if(_sta.size()==n){  /* 基图连通 */
78            ss=_sta.top(); _sta.pop(); printf(ss.c_str());
79            while(!_sta.empty()){
80                ss=_sta.top(); _sta.pop();
81                printf("."); printf(ss.c_str());
82            }printf("\n");
83        }
84        else printf("***\n");
85    }
86    return 0;
87}

_飞寒 2011-02-01 18:57 发表评论

PKU 1386 并查+欧拉路

_飞寒 — Sun, 30 Jan 2011 12:43:00 GMT

      此题不难，但因为一些细节酝酿了很久才写。最大的收获就是不同的构图角度会有截然不同的性能差异，如果把单词看作节点，那么问题将变成NP难的哈密顿回路，而如果抽象为边，将两个字母的连接抽象为对一个字母节点增加出边与入边，则瞬间变为判欧拉迹存在性的易解问题。

      欧拉环游存在定理：原图的基图为连通图，且所有定点出入度相等。
      欧拉路径存在定理：基图连通，除去出发点出度比入度多一，结束点入度比出度多一，其余点（如果有）出入度相等。

      基图判连通：并查集

1#include<cstdio>
2#include<cstdlib>
3#include<cstring>
4
5int degree[26][2];
6int set[26];
7bool hash[26];
8
9int main(){
10    int flag;
11    int inNum,outNum;
12    int _case,n,i,num;
13    char s,t,chr;
14    char tmp[1111];
15    scanf("%d",&_case);
16    while(_case--){
17        memset(degree,0,sizeof(degree));
18        memset(set,-1,sizeof(set));
19        memset(hash,0,sizeof(hash));
20        scanf("%d",&n); getchar();
21        for(i=0;i<n;i++){
22            gets(tmp);
23            s=tmp[0]; t=tmp[strlen(tmp)-1];
24            ++degree[s-'a'][0];
25            ++degree[t-'a'][1];
26            unino(s-'a',t-'a');
27            hash[s-'a']=hash[t-'a']=1;
28        }
29
30        for(num=i=0;i<26;i++) if(hash[i]) ++num;
31
32        for(flag=i=0;i<26;i++) if( set[i] == num*-1 ){ flag=true; break; }
33        /* 等价集应包含已出现的n个字母 */
34
35        if(!flag)
36            printf("The door cannot be opened.\n");  // 基图不联通
37        else{
38            flag=false;
39            for(inNum=outNum=i=0;i<26;i++)
40                if(degree[i][0]!=degree[i][1]){
41                    if(degree[i][0]==degree[i][1]+1) ++inNum;
42                    else
43                        if(degree[i][1]==degree[i][0]+1) ++outNum;
44                        else { flag=true; break; }
45                }
46            if(flag)
47                printf("The door cannot be opened.\n");
48            else
49                if( (inNum==1&outNum==1)|(inNum==0&outNum==0) )
50                    printf("Ordering is possible.\n");
51                else
52                    printf("The door cannot be opened.\n");
53        }
54    }
55    return 0;
56}
57
58int find(int s){
59    if(set[s]<0) return s;
60    set[s]=find(set[s]);
61    return set[s];
62}
63
64void unino(int s,int t){
65    int root1,root2;
66    root1=find(s); root2=find(t);
67    if( root1 == root2 ) return ;
68    if(set[root1]<set[root2]){ set[root1]+=set[root2]; set[root2]=root1; }
69    else{ set[root2]+=set[root1]; set[root1]=root2; }
70}
71

_飞寒 2011-01-30 20:43 发表评论

PKU 3259 Wormholes BF判负环

_飞寒 — Sat, 22 Jan 2011 15:11:00 GMT

题目大意：一个农民在自家农场的不同地点发现一堆虫洞，每个虫洞可以回到不同长度的过去，于是这个农民想通个时间旅行回到出发点的“过去”。

构造双向图，实际道路为正权，时光隧道为负权，题目即为判断有向图负环是否存在的裸题。。。。
中途狂RE，最后发现边数E没控制好，应为2500*2+100（有双向边）。

Bell_Ford 110ms碾过:

1#include<cstdio>
2#include<cstdlib>
3#include<cstring>
4#define N 505
5#define E 2500*2+100  // 双向边
6#define inf 10000*2500+1
7#define MIN(a,b) (a
8struct nod{int u,v,val;};
9struct nod edge[E];
10int n,m,w;
11int total;
12
13bool canBack(int s){
14    int i,j,k,d[N];
15    for(i=0;i<n;i++) d[i]=inf;
16    d[s]=0;
17    for(k=1;k<n;k++)
18        for(i=0;i<total;i++)
19            if( d[ edge[i].v ]>d[ edge[i].u ]+edge[i].val )
20                d[ edge[i].v ]=d[ edge[i].u ]+edge[i].val;
21
22    for(i=0;i<total;i++)
23        if( d[ edge[i].v ]>d[ edge[i].u ]+edge[i].val ) return true;
24
25    return false;
26}
27
28int main(){
29    int t,i,j;
30    int a,b,_val;
31    scanf("%d",&t);
32    while(t--){
33        scanf("%d%d%d",&n,&m,&w);
34        total=0;
35        for(i=0;i<m;i++){
36            scanf("%d%d%d",&a,&b,&_val); --a; --b;
37            edge[total].u=a;
38            edge[total].v=b;
39            edge[total].val=_val;
40            total++;
41            edge[total].u=b;
42            edge[total].v=a;
43            edge[total].val=_val;
44            total++;
45        }
46        for(i=0;i<w;i++){
47            scanf("%d%d%d",&a,&b,&_val); --a, --b; _val*=-1;
48            edge[total].u=a;
49            edge[total].v=b;
50            edge[total].val=_val;
51            total++;
52        }
53        if( canBack(0) ) printf("YES\n");
54        else printf("NO\n");
55    }
56    return 0;
57}

_飞寒 2011-01-22 23:11 发表评论

强连通分量-Kosaraju算法

_飞寒 — Mon, 20 Dec 2010 14:07:00 GMT

Kosaraju算法求有向图的极大连通子图。算法首先对逆图做后序遍历，求出后序编码。随后从右到左扫描编码，对于每一个未标记所属分量编号的节点，以它为根做一次DFS，标记沿途所遇到的所有节点为同一个强连通分量。

算法正确性的证明基于：任意两点s,t在原图中属于强联通分量的话，当且仅当在逆图中两者也属于同一强连通分量

#define MAXV 100000
static int postR[MAXV],post[MAXV];
static int cnt0,cnt1;

typedef struct LinkNod *Link;
struct LinkNod{
     int dest;
     Link next;
};

typedef struct GraphNod *Graph;
struct GraphNod{
     Link v[MAXV];
     int vnum;
     int id[MAXV];  // 分量标号
};

int IsScc(Graph g,int s,int t){
    return g->id[s] == g->id[t];
}

void DFS(Graph g,int w){
     g->id[w] = cnt1;
     for( Link pos = g->v[w]; pos!=NULL; pos=pos->next ) if( g->id[ pos->dest ] == -1 ) DFS(g,pos->dest);
     post[cnt0++] = w; // 后序编码
}

Graph MakeGraphR(Graph g){
     Link pos;
     Link tmpNod;
     Graph r = (Graph)malloc(sizeof(struct GraphNod));
     r->vnum = g->vnum;
     for(int i=0;i<r->vnum;i++) r->v[i] = NULL;
     for(int i=0;i<g->vnum;i++){
        pos = g->v[i];
while(pos){
     tmpNod = (Link)malloc(sizeof(struct LinkNod));
     tmpNod->dest = i; tmpNod->next = r->v[pos->dest];
     r->v[ pos->dest ] = tmpNod;
     pos=pos->next;
  }
     }
     return r;
}

int FindScc(Graph g){
   Graph r = MakeGraphR(g);
   memset(r->id,-1,sizeof(r->id));
   cnt0 = cnt1 =0;
   for( int i=0;i<r->vnum;i++ ) if( r->id[i] == -1 ) DFS(r,i);
   for(int i=0;i<g->vnum;i++) postR[i] = post[i];
   memset(g->id,-1,sizeof(g->id));
   cnt0 = cnt1 =0;
   for( int i=g->vnum-1;i>-1;i-- ) if( g->id[ postR[i] ] == -1 ){  DFS(g,postR[i]); cnt1++;  }
   printf("分量阵:\n");
   for( int i=0;i<g->vnum;i++ ) printf("%d: %d\n",i,g->id[i]);
   return cnt1;  // 分量数
}

_飞寒 2010-12-20 22:07 发表评论

双连通分量

_飞寒 — Mon, 20 Dec 2010 14:02:00 GMT

    在一个无向连通图中，如果任意去掉一个定点i及依附于i的所有边后得到的图仍然连通，
则称该图为“2-连通图”。否则，若得到多个连通分量，则该图不是双连通的，顶点i被称为
“割点 ”。
    简单的说，在双连通图中，任何一对顶点都至少存在两条路径可以互相到达。图的连通
性不会任何一个顶点的影响。这个性质具有许多重要的应用价值，例如现实中的通讯网络部署，
出于可靠性和容错性的考虑，在结构上应考虑多连通性，尽量避免割点的存在。这样就算一个
通信节点损毁，也不会对其他节点的通信造成影响。
    无向图的极大双连通子图被称为2-连通分量。一个无向图都具有一个或多个2-连通分量。
如果图本身是一个双连通图，那么它本身是自己唯一的2-连通分量。一个无向图具有2个或以
上2分量时，不难看出它的任意两个2分量最多只可能有一个公共顶点。因为如果有多于一个公
共顶点，就可以证明这两个2分量实际上可以组成一个更大的2分量，从而引起矛盾。进一步还
可以得出同一条边不可能处于多个二分量之中，因为一条边有两个顶点，如果一条边属于多个
二分量，则相当于两个顶点可以同时处于多个二分量之中，这与前述矛盾。
    综上，所有二分量实际上把图划分为了不相交的子集，连接不同二分量的边成为割边。

    可以利用深度优先搜索求2-连通分量。如果生成树的root是割点，当且仅当它有多于一个
子女。如果生成树的非根节点是割点，当且仅当它没有一个后代可以通过后向边回到它的祖先。
根据这些条件，我们定义一个点的时间戳为深度优先数，代表着顶点在深度优先搜索时被访问
的先后次序，记为D。如果D(i)知道一个顶点是不是割点，对顶点定义参数low，low[i]为从i或其后代出发，通过后向边所能达
到的最小深度优先数。

low[i]=min{ D(i) , min{low[j]|j为i的子女} , min{D(k)|(i,k)为后向边} }

    //edge为无向图边表，n为顶点数, e总边数
    void TwoCC(int n,int e){
        //D,low
        //S 栈保存二分量边
        int *D=(int *)malloc(sizeof(int)*(n+1));
        int *low=(int *)malloc(sizeof(int)*(n+1));
        int *S=(int *)malloc(sizeof(int)*(2*e));
        memset(D,0,sizeof(D));
        memset(low,0,sizeof(low));
        for(int i=0; i<n; i++){
            // 若未访问则以此为起点寻找二分量
            if(D[i]==0)
                DFS(i,-1,1,D,low,S,0);
        }
    }

    // 从u做DFS，v是u之父,num为目前深度优先数
    // top --> S
    void DFS(int u,int v,int num,int D[],int low[],int S[],int top){
        D[u]=low[u]=num++;
        Edge* l = edge[u];

        // 搜索所有与i邻接之顶点
        while(l){
            if( v!= l->dest && D[l->dest] < D[u] ){
                // 连通分量边压栈
                S[top++]=u;
                S[top++] = l->dest;
            }
            if( D[l->dest] == 0 ){
                DFS(l->dest,u,num,D,low,S,top);
                low[u]=( low[u] < low[l->dest] )? low[u] : low[l->dest];

                // 无后向边，分量结束
                if( low[l->dest] == 0 ){
                    cout<<"A 2-CC found:"<<endl;
                    do{
                        int x = S[--top];
                        int y = S[--top];
                        cout<<x<<" "<<y<<endl;
                        if( x== u && y == l->dest ) break;
                    }while(1)
                }
            }
            else
                if( l->dest != v ){
                    // 如果l-dest已经被访问过，并且不等于父顶点v，证明有后向边更新low
                    low[u] = ( low[u] < D[l->dest] ) ? low[u] : D[l->dest];
                }
            l=l->next;
        }

    }

_飞寒 2010-12-20 22:02 发表评论

USACO - The Castle

_飞寒 — Mon, 20 Dec 2010 13:55:00 GMT

        The Castle
        IOI'94

        题目大意：
                http://www.nocow.cn/index.php/Translate:USACO/castle

        分析:
            题面和要求有点啰嗦，不过总的来说还是好理解的。给定一个城堡的规格，让你求
        在围墙内可以互相联通的小房间组成的大房间的个数和尺寸。另外设法推倒一面墙，让
        两个大房间合并成更大的房间。
            这题嘛，我也不知道该分析什么，当时一看到就用图论观点做了。下面给出几个入
        手点(其实和NOCOW的大同小异了):

        1.并查集
            显然一堆互相联通的小房间属于同一个等价集，对二位的数据扫一遍然后映射到一
        维的并查集上求并。最后森林的个数自然就是大房间的个数了，一颗树的重量就是房间的
        尺寸了。这个出来推墙就好办，枚举每一面合法的墙，两边的房间求一次树根，如果不同
        根（重要细节，如果墙两次的房间是同一个大房间的话就错了~）则按要求做比较。最后
        打印，收工。

         2.floodfill
            刚开始我也不清楚这个做法（之前确实不知道，汗~）。后来看了下usaco的论文。
        其实还是很形象的，就是用BFS往上灌水，任何联通的区域都会被当前这次灌的水淹到。
        不同次灌水淹到的区域自然就是不同的大房间了。仍然不清楚的请看usaco上的论文。

         3.硬搞
            实在不会的何必想那么多呢，让小房间构成n*m的无向图，没有门的房间自然
        相邻。直接DFS联通分支。打印，收工。

        下面给出我的并查代码的 main(),求出门的方位使用位运算

int main(){
        for(step=0;step<2600;step++) ufs[step]=-1;
        fscanf(fin,"%d%d",&n,&m);
        for(step=0;step<m;step++)
                for(step2=0;step2<n;step2++)
                        fscanf(fin,"%d",&room[step][step2]);

        for(step=0;step<m;step++)
                for(step2=0;step2<n;step2++){
                        tmpNum=room[step][step2];
                        digit=0;
                        pos1=step*n+step2;
                        while(1){
                                if( (tmpNum&1) ==0){
                                        pos2=(step+door[digit][0])*n+(step2+door[digit][1]);
                                        ufsF(ufs,pos1,pos2);   // 并查相邻两个房间
                                }
                                tmpNum>>=1;
                                digit++;
                                if(tmpNum==0&&digit>3) break;
                        }
                }
        roomNum=0;
        maxSize=0;
        for(step=0;step<m*n;step++){
                if(ufs[step]<0){
                        if(ufs[step]*-1>maxSize) maxSize=ufs[step]*-1;
                        roomNum++;
                }
        }
        fprintf(fout,"%d\n%d\n",roomNum,maxSize);

        maxAdd=0;
        for(step2=0;step2<n;step2++)
            for(step=m-1;step>-1;step--){
                tmpNum=room[step][step2];
                digit=0;
                pos1=(step)*n+step2;
                while(1){
                     if((tmpNum&1)==1){
                        if(digit==2||digit==1){
                           // 从左下到右上检查每个小房间与右、上有墙隔着的小房间，若不同根则计算

                           if(step+door[digit][0]>-1&&step2+door[digit][1]<n){  // 门不是墙壁
                               pos2=(step+door[digit][0])*n+(step2+door[digit][1]);
                               root1=Find(ufs,pos1);
                               root2=Find(ufs,pos2);
                               if(root1!=root2){
                                  if(maxAdd< (ufs[root1]+ufs[root2])*-1 ){
                                     maxAdd=(ufs[root1]+ufs[root2])*-1;
                                     rm=step+1; rn=step2+1;
                                     rd=(digit==1)?'N':'E';
                                  }
                               }
                           }
                       }
                     }
                     tmpNum>>=1;
                     digit++;
                     if(tmpNum==0&&digit>3) break;
                }
           }
        fprintf(fout,"%d\n%d %d %c\n",maxAdd,rm,rn,rd);
        return 0;
}

Your satisfaction is necessary to our success. Our goal is to provide you with the best level of customer service, and we welcome your comments and suggestions

Email:

Sales: sales@CuteSoft.Net

General: info@CuteSoft.Net

Support: support@CuteSoft.Net

Address:

CuteSoft
35 SHERWOOD CRES
BELLEVILLE, ON
K8P 5G2
Canada

_飞寒 2010-12-20 21:55 发表评论

拓扑排序

_飞寒 — Mon, 20 Dec 2010 13:50:00 GMT

拓扑排序的目标是能够处理DAG的顶点，让每个顶点在它指向的所有顶点被处理
之前被处理。排序结果使得图上节点的非线性序转化为线性序，但节点的排列顺序
依然遵循原图上节点前驱与后继的传递性。

因为要做n个顶点的n次栈操作+e次入度减一运算，所以总的时间复杂度为O(n+e)。

int ToPologicalSort(int n,int degree[],Edge _edgeArr[]){
Edge tmpNod;
int l,top=-1;

RecordInDegree(n,degree,_edgeArr);  // 记录各节点入度数

for(int i=0;i<n;i++)
    if(degree[i]==0){
       degree[i]=top;  // 在原数组构造栈，入度为0节点压栈
       top=i;
    }


  for(int i=0;i<n;i++){
     if(top==-1){ printf("成环\n"); return 0;} //栈空，节点有剩余，成环
     l=top;
     top=degree[top];
     printf("%d ",l);

     tmpNod=_edgeArr[l];
     while(tmpNod){
       if(--degree[tmpNod->v]==0){  // 对应相邻节点入度减一，为0则压栈
         degree[tmpNod->v]=top;
         top=tmpNod->v;
       }
       tmpNod=tmpNod->link;
     }
  }
}

void RecordInDegree(int n,int degree[],Edge _edgeArr[]){
   Edge tmpNod; int i;
   for(i=0;i<n;i++){
      tmpNod=_edgeArr[i];
      while(tmpNod){
          degree[tmpNod->v]++;  // i相邻后继入度加一
          tmpNod=tmpNod->link;
      }
   }
}

_飞寒 2010-12-20 21:50 发表评论

Dijkstra算法_洪水泛滥

_飞寒 — Mon, 20 Dec 2010 13:28:00 GMT

仔细分析Dijkstra算法的执行过程可以发现，它与洪水泛滥有些类似。把图节点想象成洪水将要经过的城镇，所有边想象连接城镇的河道，假定洪水在源点突然爆发。
在时刻0，洪水从源头A城开始泛滥。洪水检测员可以估计洪水到达B城、C城、G城、D城的时刻分别为第i、j、k、t小时，i有限小而j,k,t为无穷大因为他们绝不与A城相邻，而B却与之相邻。前者是最保守的估计--- 情况不可能更糟了。若洪水监测员的职责仅仅是正确预报各个城市最早被淹的时间，则他大可高枕无忧睡上 min{i,j,k,t}=i 小时。当洪水到达B时，监测员着手检查所有与B相邻的有河道相邻又尚未被淹的城市，假定发现洪流从B推进到C、D、G的时间分别为12、5、7小时，于是他将C、D、G被淹时刻提前到12+j,5+k,7+t。而这个将时刻提前的动作就是Dijkstra算法里的降距操作。

int Dijkstra(int n,int s,int t, int path[])   // s为源，t为目标终点，path[n]用于跟踪各节点到源的最短路径
{
   int i,j,w,minc,d[N],mark[N];

   memset(mark,0,sizeof(mark));
   for (i=0;i<n;i++)
    {
       d[i]=g[s][i];    // 初始化点i到源的最短路，有弧赋权，无弧的置为正无穷
       path[i]=s;
    }
   mark[s]=1;
   path[s]=-1;
   d[s]=0;
   for (i=1;i<n;i++)
     {
        minc=maxint;
        for (j=0;j<n;j++)
        {
          if ((mark[j]==0)&&(minc>=d[j]))  // 若点j未被求解，且距源的长度有穷
          {minc=d[j];w=j;}
        }

        mark[w]=1;    // 归并该点
        for (j=0;j<n;j++)
        if (mark[j]==0&&d[j]>d[w]+g[w][j])
           {
             d[j]=d[w]+g[w][j];

             path[j]=w;
           }
     }
     return d[t];
}

_飞寒 2010-12-20 21:28 发表评论