図の相関アルゴリズム



  
  
  
  
  1. #ifndef _PIC_H 
  2. #define _PIC_H 
  3.  
  4. #define MAXV 50 
  5.  
  6. typedef int InfoType; 
  7. typedef char ElemType; 
  8. int visited[MAXV]; 
  9. //   
  10. typedef struct  
  11.     int no;                     //  
  12.     ElemType info;              //  
  13. }VertexType;                    //     
  14.  
  15. typedef struct  
  16.     int edge[MAXV][MAXV];       //  
  17.     int n,e;                    // ,  
  18.     VertexType vexs[MAXV]; 
  19. }MGraph;                        //  
  20.  
  21. //  
  22. typedef struct ANode            //  
  23.     int adjvex;                 //  
  24.     struct ANode *nextarc;      //  
  25.     InfoType  info;             //     
  26. }ArcNode; 
  27.  
  28. typedef struct Vnode            //  
  29.     ElemType data;              //  
  30.     ArcNode *firstarc;          //  
  31. }VNode; 
  32.  
  33. typedef VNode *AdjList[MAXV]; 
  34. typedef struct                  //  
  35.     AdjList adjlist; 
  36.     int n,e; 
  37. }AGraph; 
  38.  
  39. #endif 
  40.  
  41. #include <stdio.h> 
  42. #include "stdlib.h" 
  43. #include "pic.h" 
  44.  
  45. void CreateMat(MGraph *g, int A[][MAXV], int n) //  
  46.     int i=0,j=0; 
  47.     g->n = n; 
  48.     g->e = 0; 
  49.  
  50.     for(i=0; i<n; i++) 
  51.         for(j=0; j<n; j++)           
  52.             { 
  53.                 g->edge[i][j] = A[i][j]; 
  54.                 if(A[i][j] != 0) 
  55.                     g->e ++; 
  56.             } 
  57.  
  58. void DispMat(MGraph *g)    //    
  59.     int i,j; 
  60.     for(i=0; i<g->n; i++) 
  61.     { 
  62.         for(j=0; j<g->n; j++) 
  63.         { 
  64.             printf("%c  ",g->edge[i][j]); 
  65.         } 
  66.         printf("
    "
    ); 
  67.     } 
  68.  
  69. void CreateAdj(AGraph *g, int A[][MAXV], int n)       //  
  70.     int i=0, j=0; 
  71.     ArcNode *p = NULL;              
  72.     g = (AGraph *)malloc(sizeof(AGraph)); 
  73.     g->n = n; 
  74.     g->e = 0; 
  75.          
  76.     for(i=0; i<n; i++)   g->adjlist[i]->firstarc = NULL; 
  77.  
  78.     for(i=0; i<n; i++) 
  79.         for(j=0; j<n; j++) 
  80.             if(A[i][j] != 0) 
  81.             { 
  82.                 p = (ArcNode *)malloc(sizeof(ArcNode)); 
  83.                 p->adjvex = j; 
  84.                 p->nextarc = g->adjlist[j]->firstarc;           //     
  85.                 g->adjlist[j]->firstarc = p; 
  86.                 g->e++; 
  87.             } 
  88.  
  89. void DispAdj(AGraph *g)                                         //  
  90.     int i=0; 
  91.     ArcNode *p = NULL; 
  92.  
  93.     for(i=0; i<g->n; i++) 
  94.     { 
  95.         printf("%d  ",i); 
  96.         p = g->adjlist[i]->firstarc;                             // p  
  97.         while(p != NULL) 
  98.         { 
  99.             printf("%c ",p->adjvex); 
  100.             p = p->nextarc;                                      //  
  101.         } 
  102.         printf("
    "
    ); 
  103.     } 
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112. void InDs(AGraph *g)       //ru du 
  113.     ArcNode *p; 
  114.     int A[MAXV],i;         // store ru du 
  115.  
  116.     for(i=0; i<g->n; i++)  A[i] = 0; 
  117.  
  118.     for(i=0; i<g->n; i++) 
  119.     { 
  120.         p = (g->adjlist[i]->firstarc); 
  121.         while(p != NULL) 
  122.         { 
  123.             A[i]++; 
  124.             p = p->nextarc; 
  125.         } 
  126.     } 
  127.  
  128.     for(i=0; i<g->n; i++) 
  129.         printf("%d   ",A[i]); 
  130.  
  131. void OutDs(AGraph *g)             //chu du 
  132.     int i,n; 
  133.     ArcNode *p; 
  134.     for(i=0; i<g->n; i++) 
  135.     { 
  136.         n=0; 
  137.         p = g->adjlist[i]->firstarc; 
  138.         while(p != NULL) 
  139.         { 
  140.             n ++; 
  141.             p = p->nextarc; 
  142.             printf("%d    ",n); 
  143.         } 
  144.     } 
  145.  
  146. void Arc(AGraph *g, int i, int j)   //if there is line between i and j 
  147.     ArcNode *p = NULL; 
  148.     p = g->adjlist[i]->firstarc; 
  149.  
  150.     while(p->adjvex != j && p != NULL) 
  151.         p = p->nextarc; 
  152.     if(p == NULL)  printf(" "); 
  153.     else printf(" "); 
  154.  
  155.  
  156.  
  157.  
  158. void InDs1(MGraph *g)                 // ,  j, j  
  159.     int i,j,n; 
  160.  
  161.     for(j=0; j<g->n; j++) 
  162.     { 
  163.         n = 0; 
  164.         for(i=0; i<g->n; i++) 
  165.         { 
  166.             if(g->edge[i][j] != 0) 
  167.                 n++; 
  168.         } 
  169.         printf("%d    ",n); 
  170.     } 
  171.  
  172. void OutDs2(MGraph *g)                       //  
  173.     int  i=0,j=0,n=0; 
  174.  
  175.     for(i=0; i<g->n; i++) 
  176.     {   n=0; 
  177.         for(j=0; j<g->n; j++) 
  178.                 if(g->edge[i][j] != 0) 
  179.                     n++; 
  180.         printf("%d ",n); 
  181.     } 
  182.  
  183. void ListToMat(AGraph *g1, MGraph *g2)          //  
  184.     int i=0, j=0; 
  185.     ArcNode *p = NULL; 
  186.     g2 = (MGraph *)malloc(sizeof(MGraph)); 
  187.     g2->n = g1->n; 
  188.  
  189.     for(i=0; i<g1->n; i++)  
  190.         for(j=0; j<g1->n; j++) 
  191.             g2->edge[i][j] = 0; 
  192.  
  193.     for(i=0; i<g1->n; i++) 
  194.     { 
  195.         p = g1->adjlist[i]->firstarc; 
  196.         while(p != NULL) 
  197.         { 
  198.             g2->edge[i][p->adjvex] = 1;                     // p->adjvex  
  199.             p = p->nextaec; 
  200.         } 
  201.     } 
  202.      
  203.  
  204. //  
  205. void DFS(AGraph *g, int v)     //v  
  206.     ArcNode *p = NULL; 
  207.     visited[v] = 1; 
  208.     p = g->adjlist[v]->firstarc;    //p v  
  209.     while(p != NULL)       
  210.     { 
  211.         if(visited[p->adjvex] == 0)        //  
  212.             DFS(g,p->adjvex); 
  213.         p = p->nextarc ; 
  214.     } 
  215. /* 
  216.     * * * * 
  217.     * * * * 
  218.     * * * * 
  219.     * * * * 
  220.             
  221.         
  222. */ 
  223.  
  224. //      
  225. void BFS(AGraph *g,int v) 
  226.     ArcNode *p = NULL; 
  227.     int w,i,front =0, rear = 0; 
  228.     int queue[MAXV]; 
  229.     rear = (rear + 1) % MAXV; 
  230.     queue[rear] = v; 
  231.     for(i=0; i<g->n ; i++) visited[i] = 0; 
  232.     visited[v] = 1; 
  233.  
  234.     while(front != rear) 
  235.     { 
  236.         front = (front + 1) % MAXV; 
  237.         w = queue[front]; 
  238.         p = g->adjlist[w]->firstarc; 
  239.  
  240.         while(p != NULL)                    //  
  241.         { 
  242.             if(visited[p->adjvex] == 0) 
  243.             { 
  244.                 visited[p->adjvex] = 1; 
  245.                 rear = (rear + 1) % MAXV; 
  246.                 queue[rear] = p->adjvex; 
  247.             } 
  248.             p = p->nextarc ;                     // , , ,  
  249.         } 
  250.     } 
  251.  
  252. //    
  253. void DFS1(AGraph *g) 
  254.     int i=0; 
  255.     for(i=0; i<g->n; i++) 
  256.         if(visited[i] == 0) 
  257.             DFS(g,i); 
  258.  
  259. void BFS1(AGraph *g) 
  260.     int i=0; 
  261.     for(i=0; i<g->n; i++) 
  262.         if(visited[i] == 0) 
  263.             BFS(g,i); 
  264.  
  265. //    
  266. //   di yi ge  , while , ,  
  267. void DFS2(AGraph *g, int v) 
  268.     ArcNode *p = NULL; 
  269.     ArcNode *st[MAXV] ; 
  270.  
  271.     int i ,top = -1; 
  272.  
  273.     for(i=0; i<g->n; i++)  visited[i] = 0; 
  274.  
  275.     top++; 
  276.     st[top] = g->adjlist[v]->firstarc; 
  277.     i = st[top]->adjvex;  
  278.  
  279.     while(top > -1) 
  280.     { 
  281.         p = st[top]; top--; 
  282.         while(p != NULL) 
  283.         { 
  284.             i = st[top]->adjvex; 
  285.             if(visited[i] == 0) 
  286.             { 
  287.                 visited[i] = 1; 
  288.                 top++; 
  289.                 st[top] = g->adjlist[i]->firstarc;               
  290.                 break;                              //  ,    
  291.             } 
  292.             p = p->nextarc; 
  293.         } 
  294.     } 
  295.  
  296.  
  297. // i j  
  298. int DFSTrave(AGraph *g, int i,int j) 
  299.     int k=0; 
  300.     for(k=0; k>g->n; k++) visited[k] = 0; 
  301.     DFS(g,i);   // DFS visited  
  302.     if(visited[j] == 0)  return 0; 
  303.     else return 1; 
  304.  
  305. int BFSTrave(AGraph *g, int i,int j) 
  306.     int k=0; 
  307.     for(k=0; k>g->n; k++) visited[k] = 0; 
  308.     BFS(g,i); 
  309.     if(visited[j] == 0)  return 0; 
  310.     else return 1; 
  311.  
  312. // , , n-1 , ,  
  313. void DFS3(AGraph *g, int v) 
  314.     ArcNode *p; 
  315.     int vn=0; 
  316.     visited[v] = 1;  
  317.      
  318.  
  319.  
  320. #include <stdio.h> 
  321.  
  322. typedef struct 
  323.     int u; //  
  324.     int v; //  
  325.     int w; //  
  326. }EdgeType; 
  327.  
  328. void Prim(MGraph g, int v0) 
  329.     int lowcost[MAXV], vset[MAXV],v; // vset ,lowcost  
  330.     int i,j,k,min; 
  331.     v =v0; 
  332.     vset[v0] = 1; 
  333.  
  334.     for(i=0; i<g.n; i++)  // vset , lowcost     
  335.         if(i != v0) 
  336.         { 
  337.             lowcost[i] = g.edge[v0][i]; 
  338.             vset[i] = 0; 
  339.         }    
  340.  
  341.     for(j=1; j<g.n; j++) // n-1  
  342.     { 
  343.         min = INF; 
  344.         for(k=0; k<g.n; k++)       //   v0  
  345.         { 
  346.             if(vset[k] != 0 && lowcost[k] < min) 
  347.             { 
  348.                 min = lowcost[k]; 
  349.                 k = j; 
  350.             } 
  351.         } 
  352.         printf("   (%d, %d) : %d
    "
    , v,k,min); 
  353.         v=k;                            //v v0 , v    
  354.         vset[k] = 1; 
  355.  
  356.         for(j=0; j<g.n; j++)           //  
  357.             if(vset[v][j] == 0 && g.edge[v][j] < lowcost[j]) 
  358.                 lowcost[j] = g.edge[v][j]; 
  359.  
  360.     } 
  361.  
  362.  
  363. void InsetSort(EdgeType E[], int n) 
  364.     int i,j; 
  365.     EdgeType temp; 
  366.     for(i=0; i<n; i++) 
  367.     { 
  368.         temp = E[i]; 
  369.         j = i-1;                        //  
  370.  
  371.         while(j>=0 && E[j].w > temp.w)    //  E[i]   
  372.         { 
  373.             E[j+1] = E[j]; 
  374.             j--; 
  375.         } 
  376.         E[j+1] = temp; 
  377.     } 
  378.  
  379. void Kruskal(MGraph g) 
  380.     EdgeType E[MAXV]; 
  381.     int i,j,m1,m2,sn1,sn2,k; 
  382.     int vset[MAXV]; 
  383.     k=0; 
  384.     for(i=0; i<g.n; i++)               // E[]  
  385.         for(j=0; j<g.n; j++) 
  386.             if(g.edge[i][j] != 0 && g.edge[i][j] != INF) 
  387.             { 
  388.                 E[k].u = i; E[k].v = j; E[k].w = g.edge[i][j]; 
  389.                 k++; 
  390.             } 
  391.     InseSort(E,g.e); 
  392.  
  393.     for(i=0; i<g.n; i++)  vset[i] = i; 
  394.     k=1; j=0;            //k  n-1  ,j  
  395.     while(k<g.n) 
  396.     { 
  397.         m1= E[j].u; m2 = E[j].v;  
  398.         sn1 = vset[m1]; sn2 = vset[m2]; 
  399.         if(sn1 != sn2)           //   vset  
  400.         { 
  401.             printf(" (%d, %d) :%d",m1,m2,E[j].w); 
  402.             k++; 
  403.             for(i=0; i<g.n; i++) 
  404.                 if(vset[i] == sn2) 
  405.                     vset[i] = sn1; 
  406.         } 
  407.         j++; 
  408.     } 
  409.  
  410. //  
  411. #include <stdio.h> 
  412.  
  413. int path[MAXV]; 
  414. int v1[MAXV],v2[MAXV]; 
  415. int vn,vm;                  //vn ,v1 ,vm       
  416.  
  417. int cond(int path[],int d)     //d path    
  418.     int i,j; 
  419.     int flag1=0, f1, flag2=0, f2; 
  420.  
  421.     for(i=0; i<vn; i++) 
  422.     { 
  423.         f1=1; 
  424.         for(j=0; j<=d; j++) 
  425.             if(path[j] == v1[i]) 
  426.             { 
  427.                 f1=0; 
  428.                 break
  429.             } 
  430.         flag1 += f1; 
  431.     } 
  432.  
  433.     for(i=0; i<vm; i++) 
  434.     { 
  435.         f2=0; 
  436.         for(j=0; j<=d; j++)      
  437.             if(path[j] == vm[i]) 
  438.             { 
  439.                 f2=1; 
  440.                 break
  441.             }        
  442.         flag2 += f2; 
  443.     } 
  444.  
  445.     if(flag1 == 0 && flag2 == 0)  return 1; 
  446.     else return 0; 
  447.  
  448.  
  449. // vi vj     
  450.  
  451. void TravPath(AGraph *g, int vi, int vj, int d) 
  452.     int v,i; 
  453.     ArcNode *p; 
  454.     d++; 
  455.     visited[vi] = 1;     
  456.     path[d] = vi;                //      visited  
  457.  
  458.     if(vi == vj && Cond(path,d) == 1) 
  459.     { 
  460.         for(i=0; i<=d; i++)  printf("%d  ",path[i]); 
  461.         printf("
    "
    ); 
  462.     } 
  463.  
  464.     p = g->adjlist[vi]->firstarc; 
  465.     while(p != NULL) 
  466.     { 
  467.         v = p->adjvex; 
  468.         if(visited[v] == 0)      
  469.             TravPath(g,v,vj,d); 
  470.         p = p->nextarc ; 
  471.     } 
  472.     visited[vi] = 0;        // ,  
  473.     d--; 
  474.  
  475.  
  476.  
  477.  
  478.  
  479. // ,  
  480. // , visited 1 
  481.  
  482. void MDFS(MGraph g, int v) 
  483.     int j; 
  484.     visited[v] = 1;              // visited  
  485.     for(j=0; j<g.n; j++) 
  486.         if(g.edge[v][j] != 0 && g.edge[v][j] != INF && visited[j] == 0) 
  487.             MDFS(g,j); 
  488.  
  489. int DGRoot1(MGraph g) 
  490.     int i,j,k,n; 
  491.     for(i=0; i<g.n; i++) 
  492.     { 
  493.         for(j=0; j<g.n; j++)  visited[j] = 0; 
  494.         MDFS(g,i); 
  495.         n = 0; 
  496.         for(k=0; k<g.n; k++) 
  497.             if(visited[k] == 1) n++; 
  498.         if(n == g.n) return i; 
  499.     } 
  500.  
  501. void MBFS(MGraph g, int v) 
  502.     int qu[MAXV], front =0, rear = 0; 
  503.     int i,j; 
  504.  
  505.     visited[v] = 1; 
  506.     rear = (rear + 1) % MAXV; 
  507.     qu[rear] = v; 
  508.  
  509.     while(front != rear)  
  510.     { 
  511.         front = (front + 1) % MAXV; 
  512.         i = qu[front]; 
  513.  
  514.         for(j=0; j<g.n; j++)      // , i  
  515.         { 
  516.             if(g.edge[i][j] != 0 && g.edge[i][j] != INF) 
  517.             { 
  518.                 if(visited[j] == 0) 
  519.                 { 
  520.                     visited[j] = 1; 
  521.                     rear = (rear + 1) % MAXV; 
  522.                     qu[rear] = j; 
  523.                 } 
  524.             } 
  525.         } 
  526.     } 
  527.  
  528. int DGRoot2(MGraph g) 
  529.     int i,j,k,n; 
  530.     for(i=0;  i<g.n; i++) 
  531.     { 
  532.         for(j=0; j<g.n; j++)  visited[j] = 0; 
  533.         BDFS(g,i); 
  534.         n=0; 
  535.         for(k=0; k<g.n; k++) 
  536.             if(visited[k] == 1)  n++; 
  537.         if(n == g.n)  return 1; 
  538.         else return 0; 
  539.     }