图着问题的DSATUR近似算法

最新推荐文章于 2023-08-22 15:55:47 发布
最新推荐文章于 2023-08-22 15:55:47 发布
阅读量2.8k 收藏 3
点赞数
文章标签： 算法 colors buffer fp graph null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Feisy/article/details/2319453
版权
学习近似算法的资料少，我做毕业设计才接触这方面的东西。估摸着兄弟们也有这个问题，现把我手里的代码共享出来，拿的人回个贴，算对我的支持。迟点我看情况要不要把图着色的可视化程序贴出来
/**/

/*
   COLOR.C: Easy code for graph coloring
   Author: Michael A. Trick, Carnegie Mellon University, trick+@cmu.edu
   Last Modified: November 2, 1994


Graph is input in a file.  First line contains the number of nodes and
edges.  All following contain the node numbers (from 1 to n) incident to 
each edge.  Sample:

4 4
1 2
2 3
3 4
1 4

represents a four node cycle graph.

Code is probably insufficiently debugged, but may be useful to some people.

For more information on this code, see Anuj Mehrotra and Michael A. Trick,
"A column generation approach to graph coloring", GSIA Technical report series.

*/

#include  < stdio.h >
#include  < math.h >
#include  < stdlib.h >
#include  < sys / types.h >
#include  < sys / times.h >

#define  MAX_RAND (2.0*(1 << 30))
#define  MAX_NODE 600
#define  TRUE 1
#define  FALSE 0
#define  INF 100000.0

struct  tms buffer;             /* structure for timing              */
int  current_time,start_time;
 double  utime;

 int  adj[MAX_NODE][MAX_NODE];
 int  BestColoring;
 int  num_node;
 int  ColorClass[MAX_NODE];
 int  prob_count;
 int  Order[MAX_NODE];
 int  Handled[MAX_NODE];
 int  ColorAdj[MAX_NODE][MAX_NODE];
 int  ColorCount[MAX_NODE];
 int  lb;
 int  num_prob,max_prob;


 int  best_clique;


 int  greedy_clique(valid,clique)
 int   * valid, * clique;

 {
  int i,j,k;
  int max;
  int place,done;
  int *order;
  int weight[MAX_NODE];
  
  for (i=0;i<num_node;i++) clique[i] = 0;
  order = (int *)calloc(num_node+1,sizeof(int));
  place = 0;
  for (i=0;i<num_node;i++) {
    if (valid[i]) {
      order[place] = i;
      place++;
    }
  }
  for (i=0;i<num_node;i++)
    weight[i] = 0;
  for (i=0;i<num_node;i++) 
    {
      if (!valid[i]) continue;
      for (j=0;j<num_node;j++) 
    {
      if (!valid[j]) continue;
      if (adj[i][j]) weight[i]++;
    }
    }
  

  done = FALSE;
  while (!done) {
    done = TRUE;
    for (i=0;i<place-1;i++) {
      j = order[i];
      k = order[i+1];
      if (weight[j] < weight[k]) {
    order[i] = k;
    order[i+1] = j;
    done = FALSE;
      }
    }
  }


  clique[order[0]] = TRUE;
  for (i=1;i<place;i++) {
    j = order[i];
    for (k=0;k<i;k++) {
      if (clique[order[k]] && !adj[j][order[k]]) break;
    }
    if (k==i) {
      clique[j] = TRUE;
    }
    else clique[j] = FALSE;
    
  }
  max = 0;
  for (i=0;i<place;i++) 
    if (clique[order[i]]) max ++;
  
  free(order);
/*  printf("Clique found of size %d ",max);*/
  
  return max;
}

/* Target is a goal value:  once a clique is found with value target
   it is possible to return
   
   Lower is a bound representing an already found clique:  once it is
   determined that no clique exists with value better than lower, it
   is permitted to return with a suboptimal clique.

   Note, to find a clique of value 1, it is not permitted to just set
   the lower to 1:  the recursion will not work.  Lower represents a
   value that is the goal for the recursion.
*/

int  max_w_clique(valid,clique,lower,target)
 int   * valid, * clique;
 int  lower,target;


 {
  int start,j,k;
  int incumb,new_weight;
  int *valid1,*clique1;
  int *order;
  int *value;
  int i,place,finish,done,place1,place2;
  int total_left;
  
/*  printf("entered with lower %d target %d ",lower,target);*/
  num_prob++;
  if (num_prob > max_prob) return -1;
  for (j=0;j<num_node;j++) clique[j] = 0;
  total_left = 0;
  for (i=0;i<num_node;i++)
    if (valid[i]) total_left ++;
  if (total_left < lower) {
    return 0.0;
  }

  order = (int *)calloc(num_node+1,sizeof(int));
  value = (int *) calloc(num_node,sizeof(int));
  incumb = greedy_clique(valid,clique);
  if (incumb >=target) return incumb;
  if (incumb > best_clique) {
    best_clique=incumb;
/*    printf("Clique of size %5d found. ",best_clique);*/
  }
/*  printf("Greedy gave %f ",incumb);*/
  
  place = 0;
  for (i=0;i<num_node;i++) {
    if (clique[i]) {
      order[place] = i;
      total_left --;
      place++;
    }
  }
  start = place;
  for (i=0;i<num_node;i++) {
    if (!clique[i]&&valid[i]) {
      order[place] = i;
      place++;
    }
  }
  finish = place;
  for (place=start;place<finish;place++) {
    i = order[place];
    value[i] = 0;
    for (j=0;j<num_node;j++) {
      if (valid[j] && adj[i][j]) value[i]++;
    }
  }

  done = FALSE;
  while (!done) {
    done = TRUE;
    for (place=start;place<finish-1;place++) {
      i = order[place];
      j = order[place+1];
      if (value[i] < value[j] ) {
    order[place] = j;
    order[place+1] = i;
    done = FALSE;
      }
    }
  }
  free(value);
  for (place=start;place<finish;place++) {
    if (incumb + total_left < lower) {
      return 0;
    }
    
    j = order[place];
    total_left --;
    
    if (clique[j]) continue;
    
    valid1 = (int *)calloc(num_node,sizeof(int));
    clique1 = (int *)calloc(num_node,sizeof(int));
    for (place1=0;place1 < num_node;place1++) valid1[place1] = FALSE;
    for (place1=0;place1<place;place1++) {
      k = order[place1];
      if (valid[k] && (adj[j][k])){
    valid1[k] = TRUE;
      }
      else
    valid1[k] = FALSE;
    }
    new_weight = max_w_clique(valid1,clique1,incumb-1,target-1);
    if (new_weight+1 > incumb)  {
/*      printf("Taking new ");*/
      incumb = new_weight+1;
      for (k=0;k<num_node;k++) clique[k] = clique1[k];
      clique[j] = TRUE;
      if (incumb > best_clique) {
    best_clique=incumb;
/*    printf("Clique of size %5d found. ",best_clique);*/
      }
    }
    
  /*    else printf("Taking incumb ");*/
    free(valid1);
    free(clique1);
    if (incumb >=target) break;
  }
  free(order);
  return(incumb);
}



AssignColor(node,color)
 int  node,color;

 {
  int node1;

/*  printf("  %d color +%d ",node,color);*/
  ColorClass[node] = color;
  for (node1=0;node1<num_node;node1++) 
    {
      if (node==node1) continue;
      if (adj[node][node1]) 
    {
      if (ColorAdj[node1][color]==0) ColorCount[node1]++;
      ColorAdj[node1][color]++;
      ColorAdj[node1][0]--;
      if (ColorAdj[node1][0] < 0) printf("ERROR on assign ");    
    }
    }
  
}


RemoveColor(node,color)
 int  node,color;

 {
  int node1;
/*  printf("  %d color -%d ",node,color);  */
  ColorClass[node] = 0;
  for (node1=0;node1<num_node;node1++) 
    {
      if (node==node1) continue;
      if (adj[node][node1]) 
    {
      ColorAdj[node1][color]--;
      if (ColorAdj[node1][color]==0) ColorCount[node1]--;
      if (ColorAdj[node1][color] < 0) printf("ERROR on assign ");
      ColorAdj[node1][0]++;
    }
    }
  
}

/*int lower_bound(current_color) 
     int current_color;

{
  int i,j,k;
  int max;
  int done;
  int clique[MAX_NODE];
  int order[MAX_NODE];
  int weight[MAX_NODE];
  
  for (i=0;i<num_node;i++) clique[i] = 0;
  for (i=0;i<num_node;i++) {
    order[i] = i;
    weight[i] = ColorAdj[i][0];
    for (k=1;k<=current_color;k++)
      if (ColorClass[i] != k) weight[i] +=ColorAdj[i][k];
  }
  
  done = FALSE;
  while (!done) {
    done = TRUE;
    for (i=0;i<num_node-1;i++) {
      j = order[i];
      k = order[i+1];
      if (weight[j] < weight[k]) {
    order[i] = k;
    order[i+1] = j;
    done = FALSE;
      }
    }
  }
  clique[order[0]] = TRUE;
  printf("Node %d in clique ",order[0]);
  for (i=1;i<num_node;i++) {
    j = order[i];
    for (k=0;k<i;k++) {
      if (clique[order[k]]) {
    if (!adj[j][order[k]]) 
      {
        if ((ColorClass[order[k]]==0) || (ColorClass[j]==0) ||(ColorClass[order[k]]==ColorClass[j]))
          break;
      }
      }
    }
    if (k==i) {
      clique[j] = TRUE;
      printf("Node %d in clique ",j);
    }
  }
  max = 0;
  for (i=0;i<num_node;i++) 
    if (clique[order[i]]) max++;
  printf("Lower bound of %d found with Best Coloring %d ",max,BestColoring);
  return max;
}
*/

/*int lower_bound(current_color)
int current_color;
{
  return 0;
  
}
*/

int  color(i,current_color)
      int  i;
 {
  int j,new_val;
  int k,max,count,place;
  

  prob_count++;
  if (current_color >=BestColoring) return(current_color);
  if (BestColoring <=lb) return(BestColoring);
  
  if (i >= num_node) return(current_color);
/*  printf("Node %d, num_color %d ",i,current_color);*/
  
/* Find node with maximum color_adj */
  max = -1;
  place = -1;
  for(k=0;k<num_node;k++) 
    {
/*      count = 0;*/
      if (Handled[k]) continue;
/*      for (j=1;j<=current_color;j++)
    if (ColorAdj[k][j] > 0) count++;
      if (count!=ColorCount[k]) printf("Trouble with color count ");
*/      
/*      printf("ColorCount[%3d] = %d ",k,ColorCount[k]);*/
      if ((ColorCount[k] > max) || ((ColorCount[k]==max)&&(ColorAdj[k][0]>ColorAdj[place][0])))
    {
/*      printf("Best now at %d ",k);*/
      max = ColorCount[k];
      place = k;
    }
    }
  if (place==-1) 
    {
      printf("Graph is disconnected.  This code needs to be updated for that case. ");
      exit(1);
    }

  
  Order[i] = place;
  Handled[place] = TRUE;
/*  printf("Using node %d at level %d ",place,i);*/
  for (j=1;j<=current_color;j++) 
    {
      if (!ColorAdj[place][j]) 
    {
      ColorClass[place] = j;
      AssignColor(place,j);
      new_val = color(i+1,current_color);
      if (new_val < BestColoring){
        BestColoring = new_val;
        print_colors();
      }
      RemoveColor(place,j);
      if (BestColoring<=current_color) {
        Handled[place] = FALSE;
        return(BestColoring);
      }
    }
    }
  if (current_color+1 < BestColoring) 
    {
      ColorClass[place] = current_color+1;
      AssignColor(place,current_color+1);
      new_val = color(i+1,current_color+1);
      if (new_val < BestColoring) {
    BestColoring = new_val;
    print_colors();
      }
      
      RemoveColor(place,current_color+1);
    }
  Handled[place] = FALSE;
  return(BestColoring);
}

print_colors() 
 {
  int i,j;

  times(&buffer);
  current_time = buffer.tms_utime;
  
  printf("Best coloring is %d at time %7.1f ",BestColoring,(current_time-start_time)/60.0);
  
/*  for (i=0;i<num_node;i++)
    printf("Color[%3d] = %d ",i,ColorClass[i]);*/
  for (i=0;i<num_node;i++)
    for (j=0;j<num_node;j++) 
      {
    if (i==j) continue;
    if (adj[i][j] && (ColorClass[i]==ColorClass[j]))
      printf("Error with nodes %d and %d and color %d ",i,j,ColorClass[i]);
      }
}

main(argc,argv)
   int  argc; 
   char   * argv[];
 {
  FILE *fp;
  int m,i,j,k,val;
  int valid[MAX_NODE],clique[MAX_NODE];
  int place;
  
  if (argc < 2) 
    {
      printf("Provide data file in command. ");
      exit(1);
    }
  
  if ((fp = fopen(argv[1],"r"))==NULL) 
    {
      printf("No such graph as %s ",argv[1]);
      exit(1);
    }
  
  fscanf(fp,"%d %d",&num_node,&m);
  for (i=0;i<num_node;i++)
    for (j=0;j<num_node;j++) 
      {
    adj[i][j] = FALSE;
      }

  for (k=0;k<m;k++) {
    fscanf(fp,"%d %d",&i,&j);
    adj[i-1][j-1] = TRUE;
    adj[j-1][i-1] = TRUE;
  }
  fclose(fp);


  prob_count = 0;
  for (i=0;i<num_node;i++)
    for (j=0;j<=num_node;j++)
      ColorAdj[i][j] = 0;
  for (i=0;i<num_node;i++)
    for (j=0;j<num_node;j++)
      if (adj[i][j]) ColorAdj[i][0]++;
  for (i=0;i<num_node;i++)
    ColorCount[i]=0;
  times(&buffer);
  start_time=buffer.tms_utime;
  printf("Graph %s read with %d nodes and %d edges ",argv[1],num_node,m);
  for (i=0;i<num_node;i++)
    Handled[i] = FALSE;
  BestColoring = num_node+1;
/*  ColorClass[0] = 1;
  AssignColor(0,1);
  Handled[0] = TRUE;*/
  for (i=0;i<num_node;i++) valid[i] = TRUE;
  best_clique = 0;
  num_prob = 0;
  max_prob = 10000;
  
  lb = max_w_clique(valid,clique,0,num_node);
  place = 0;
  for (i=0;i<num_node;i++) 
    {
      if (clique[i]) 
    {
      Order[place] = i;
      Handled[i] = TRUE;
      place++;
      AssignColor(i,place);
      for (j=0;j<num_node;j++)
        if ((i!=j)&&clique[j] && (!adj[i][j])) printf("Result is not a clique! ");
      
    }
    }
  
  printf("Lower bound is %d",lb);
  if (num_prob >=max_prob) printf(" (not confirmed) ");
  else printf(" ");
  val = color(place,place);
  times(&buffer);
  current_time=buffer.tms_utime;
  
  printf("Best coloring has value %d, subproblems: %d time:%7.1f ",val,prob_count,(current_time-start_time)/60.0);
  
}
    
 
Feisy
关注
java 地图四色着色算法_趣味地图系列之6 四色定理之我见
weixin_42134094的博客
12-26 1282
四色定理（four color map theorem）是一个著名的数学定理[1]，即对任意的（平面上的）地图染色，要求相邻的国家颜色不同，四种颜色即可完成着色。 南非数学家法兰西斯·古德里在1852年提出“四色问题”或“四色猜想”。证明宽松一点的“五色定理”（即“只用五种颜色就能为所有地图染色”）很容易，但是四色定理证明持续了很长时间。 四色定理不是地图学的定理，四色定...
网络分析优化图着色算法Vertex Coloring算法初探
wsh6759的CGIS专栏
11-26 1773
网络分析优化图着色算法Vertex Coloring算法初探                                               By wangsh 2011-11-26   网络图分析中，Vertex Coloring是一个重要研究内容（参考1，2），是Graph Coloring的一部分，但是Edge Coloring可以转化为Vertex Colori
图的着色问题的近似算法；并行机调度的近似算法LPTc(|I|)算法
09-19
利用四色原理写出以及于任意图着色的1—近似算法; R(|I|)——近似算法主要思想是：无论何时，当一台机器空闲时，列表中下一个任务可被分配到该机器上进行处理。 LPTc(|I|)是在上面近似算法的基础上，除了先对任务进行预排序（变成由时间从小到大排）预处理外，再对前c个任务用穷举法实现最优调度（暂时该步计划采用回溯法，由于过程还有待进一步清晰，而且，有待将调度明细详细输出，故有待完善），最后对剩下的n-c个任务采用上述近似算法 ; 代码、文档详尽，是《算法设计与分析（高级教程）》实验报告与源码
涂色问题dsatur算法的Matlab简单程序
qq_59287685的博客
08-22 137
【代码】涂色问题dsatur算法的Matlab简单程序。
图论着色问题matlab程序
05-30
图论着色问题的Matlab应用程序.可画出任意节点个数的空图和完全图，可以输入任意矩阵并画图，并求出色多项式。
echarts map 点击地图区域变色_趣味地图系列之6 四色定理之我见
weixin_39585974的博客
11-04 442
四色定理(four color map theorem)是一个著名的数学定理[1]，即对任意的(平面上的)地图染色，要求相邻的国家颜色不同，四种颜色即可完成着色。 南非数学家法兰西斯·古德里在1852年提出“四色问题”或“四色猜想”。证明宽松一点的“五色定理”(即“只用五种颜色就能为所有地图染色”)很容易，但是四色定理证明持续了很长时间。 四色定理...
"图着色问题的加权版本：分支和价格算法
可在www.sciencedirect.com在线获取理论计算机科学电子笔记346（2019）613-624...特别是，列表着色问题推广了著名的图着色问题，许多精确的算法已经开发出来在这项工作中，我们提出了一个分支和价格算法
图着色问题的Python算法原理：源码分析与实现
[图着色问题的Python算法原理：源码分析与实现](https://img-blog.csdnimg.cn/dfb09255f60d4d2fa01125a54cabf851.png) # 1. 图着色问题概述 ## 1.1 图着色问题的定义 图着色问题是计算机科学和图论中的经典问题之一...
MATLAB设计_蚁群优化算法实现.zip
最新发布
05-27
为了提高算法的性能和稳定性，可能还需要引入一些改进策略，如 elitism（精英策略）保留最好的解，local search（局部搜索）提升解的质量，或者采用不同形式的信息素更新策略，如DEA（动态信息素蒸发率）或DSATUR...
蚁群算法 模拟蚁群算法 很不错
09-04
因此，研究者们提出了许多改进版本，如 elitist ACO（精英蚁群算法）、DSATUR ACO（饱和度启发式蚁群算法）等，以提高算法性能。 在实际应用中，蚁群算法可以应用于诸多领域，如物流配送、交通网络优化、任务调度、...
启发式与元启发式作业之GCP
qq_25272901的博客
11-07 1717
图染色问题解决示例（GCP）引言1.问题基本描述2.三种方法的实现2.1DSATUR2.1.1主要过程流程2.1.2主要数据结构2.1.3完整代码2.1.4结果展示2.2禁忌搜索2.2.1主要过程流程2.2.2主要数据结构2.2.3完整代码2.2.4结果展示2.3模拟退火2.3.1主要过程流程2.3.2主要数据结构2.3.3·完整代码2.3.4结果展示 引言 图着色问题（Graph Coloring Problem, GCP）又称着色问题，是最著名的NP-完全问题之一。这个问题是启发式与元启发式算法课上的一
图着色算法详解
chenglinhust的专栏
06-20 2万+
图着色算法详解 图着色算法简介        图的m-着色判定问题——给定无向连通图G和m种不同的颜色。用这些颜色为图G的各顶点着色，每个顶点着一种颜色，是否有一种着色法使G中任意相邻的2个顶点着不同颜色?        图的m-着色优化问题——若一个图最少需要m种颜色才能使图中任意相邻的2个顶点着不同颜色，则称这个数m为该图的色数。求一个图的最小色数m的问题称为m-着色优化问题。
NP完全性理论与近似算法
weixin_33670713的博客
12-06 533
一、图灵机 根据有限状态控制器的当前状态及每个读写头读到的带符号，图灵机的一个计算步可实现下面3个操作之一或全部。 （1）改变有限状态控制器中的状态。 （2）清除当前读写头下的方格中原有带符号并写上新的带符号。 （3）独立地将任何一个或所有读写头，向左移动一个方格(L)或向右移动一个方格(R)或停在当前单元不动(S)。 k带图灵机可形式化地描述为一个7元组(Q，T，I，δ，b，q0，qf...
无向图的极大团、最大团(Bron-Kerbosch算法)
热门推荐
yo_bc的博客
08-21 2万+
描述：团就是最大完全子图。(极大团) 给定无向图G=(V,E)。如果U包含于V，且对任意u，v属于U且有(u，v)属于E，则称U是G的完全子图。 G的完全子图U是G的团当且仅当U不包含在G的更大的完全子图中，即U就是最大完全子图。 G的最大团是指G中所含顶点数最多的团。 // 最大团： V中取K个顶点，两点间相互连接 // 最大独立集： V中取K个顶点，两点间不连接 // 最大...
dsa算法（15）
wuhui_gdnt的专栏
11-06 2509
1.3.4. DominatorTree遍 DominatorTree的基类FunctionPass具有一个系统可以预期、可预测的局部行为。在一个程序中，所有FunctionPass在每个函数上执行，而不依赖于其它任何函数。FunctionPass不要求以一个特定的次序执行，并且FunctionPass不改变外部函数。 明确说来，FunctionPass不允许： 查看或修改当前没有处理的
贪心算法之区间图着色问题
lwtb的博客
07-10 7472
CLRS 16.1-3 假设要用很多个教室对一组活动进行调度。我们希望使用尽可能少的教室来调度所有的活动。请给出一个有效的贪心算法，来确定哪一个活动应使用哪一个教室。 (这个问题也被成为区间图着色(interval-graph coloring)问题。我们可作出一个区间图，其顶点为已知的活动，其边连接着不兼容的活动。为使任两个相邻结点的颜色均不相同，所需的最少颜色对应于找出调度给定的所有活动所需
JAVA算法：无向图的着色（Graph Coloring）问题
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
07-08 4517
图着色（Graph Coloring）问题 图着色问题（Graph Coloring Problem, GCP） 又称着色问题，是最著名的NP—完全问题之一。道路着色问题（Road Coloring Problem）是图论中最著名的猜想之一。 数学定义：给定一个无向图 G=（V, E），其中V为顶点集合，E为边集合，图着色问题即为将V分为K个颜色组，每个组形成一个独立集，即其中没有相邻的顶点...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值