1. hust 1017 DLX精确覆盖 模板题

勉强写了注释，但还是一脸懵逼，感觉插入方式明显有问题但又不知道哪里不对而且好像能得出正确结果真是奇了怪了

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <queue>
  5.  #include <map>
  6.  #include <vector>
  7.  #include <string>
  8.  #include <cstring>
  9.  #include <algorithm>
  10.  #include <math.h>
  11.  
  12.  #define SIGMA_SIZE 26
  13.  #define lson rt<<1
  14.  #define rson rt<<1|1
  15.  #pragma warning ( disable : 4996 )
  16.  
  17.  using namespace std;
  18.  typedef long long LL;
  19.  inline LL LMax(LL a,LL b)    { return a>b?a:b; }
  20.  inline LL LMin(LL a,LL b)    { return a>b?b:a; }
  21.  inline int Max(int a,int b) { return a>b?a:b; }
  22.  inline int Min(int a,int b) { return a>b?b:a; }
  23.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  24.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  25.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  26.  const LL mod  = ;
  27.  const int inf  = 0x3f3f3f3f;
  28.  const int maxk = 1e5+;
  29.  const int maxn = 1e4+;
  30.  
  31.  //第一行为虚拟行，是人为加上的，一共有m+1个点（第一个点独立于整个矩阵）
  32.  //而后加入的值为1的点标号用size表示
  33.  //即第一行一共m+1个点，所以size先从0~m，之后每加入一个为1的点，size++
  34.  //大部分数组X都用X[size]来标识标号为size的点的信息
  35.  struct DLX {
  36.      int n, m, size, fin;
  37.      int U[maxn], D[maxn], L[maxn], R[maxn];//上下左右
  38.      int head[maxn], S[maxn];                //分别存每一行第一个1的点的标号和每一列1的个数
  39.      int row[maxn], col[maxn], ans[maxn];    //row,col表示第size个点在哪一行/列
  40.  
  41.      void init( int _n, int _m )
  42.      {
  43.          n = _n; m = _m;
  44.          for ( int i = ; i <= m; i++ )    //初始化第一行（人为增加的虚拟行）
  45.          {
  46.              S[i] = ;
  47.              U[i] = D[i] = i;
  48.              L[i] = i-;
  49.              R[i] = i+;
  50.          }
  51.          R[m] = ; L[] = m;        //第一行的最后一个元素指向第一个
  52.          size = m;                //从m开始以后都是普通节点
  53.          memset( head, -, sizeof(head) );
  54.          head[] = ;
  55.      }
  56.  
  57.      void link( int r, int c )
  58.      {
  59.          size++;                    //得到新的点标号
  60.          col[size] = c;            //第size个点在第c列
  61.          row[size] = r;            //第size个点在第r行
  62.          S[c]++;                    //第c列1的个数+1
  63.  
  64.          //组成一个环，和下面左右一样的插法
  65.          D[size] = D[c];
  66.          U[size] = c;
  67.          U[D[c]] = size;
  68.          D[c] = size;        
  69.  
  70.          //如果该行没有为1的节点
  71.          if ( head[r] <  ) head[r] = L[size] = R[size] = size;
  72.          else
  73.          {
  74.              //组成一个环,插在head[r]和head[r]右边那个元素中间
  75.              R[size] = R[head[r]];
  76.              L[R[size]] = size;
  77.              L[size] = head[r];
  78.              R[head[r]] = size;
  79.          }
  80.      }
  81.  
  82.      void remove( int c )   //删除列c及其所在行
  83.      {
  84.          L[R[c]] = L[c]; R[L[c]] = R[c];                //c的左右两个节点互相连接
  85.          for ( int i = D[c]; i != c; i = D[i] )        //屏蔽c列
  86.              for ( int j = R[i]; j != i; j = R[j] )
  87.              {
  88.                  U[D[j]] = U[j];
  89.                  D[U[j]] = D[j];
  90.                  --S[col[j]];        //j所在的列的1的数目数减少
  91.              }
  92.      }
  93.  
  94.      void resume( int c )
  95.      {
  96.          for ( int i = U[c]; i != c; i = U[i] )
  97.              for ( int j = L[i]; j != i; j = L[j] )
  98.              {
  99.                  U[D[j]] = D[U[j]] = j;
  100.                  ++S[col[j]];
  101.              }
  102.          L[R[c]] = R[L[c]] = c;
  103.      }
  104.  
  105.      bool dance( int d )
  106.      {
  107.          if ( R[] ==  ) //第0行没有节点
  108.          {
  109.              fin = d;
  110.              return true;
  111.          }
  112.  
  113.          //找出含1数目最小的一列
  114.          int mark = R[];
  115.          for ( int i = R[]; i != ; i = R[i] )
  116.              if ( S[i] < S[mark] )
  117.                  mark = i;
  118.  
  119.          remove(mark);    //移除列mark的1的对应行
  120.          for ( int i = D[mark]; i != mark; i = D[i] )
  121.          {
  122.              ans[d] = row[i];
  123.              //移除该行的1的对应列
  124.              for ( int j = R[i]; j != i; j = R[j] )
  125.                  remove(col[j]);
  126.  
  127.              if ( dance(d+) )
  128.                  return true;
  129.  
  130.              //倒着恢复
  131.              for ( int j = L[i]; j != i; j = L[j] )
  132.                  resume(col[j]);
  133.          }
  134.          resume(mark);
  135.          return false;
  136.      }
  137.  }dlx;
  138.  
  139.  int main()
  140.  {
  141.      //freopen("F:\\cpp\\test.txt","r",stdin); 
  142.  
  143.      int n, m;
  144.      while ( ~scanf("%d %d", &n, &m) )
  145.      {
  146.          dlx.init(n,m);
  147.          for ( int i = ; i <= n; i++ )
  148.          {
  149.              int num, j;
  150.              scanf("%d",&num);
  151.              while (num--)
  152.              {
  153.                  scanf("%d",&j);
  154.                  dlx.link(i,j);
  155.              }
  156.          }
  157.  
  158.          if ( dlx.dance() )
  159.          {
  160.              printf( "%d", dlx.fin );
  161.              for ( int i = ; i < dlx.fin; i++ )
  162.                  printf( " %d", dlx.ans[i] );
  163.              printf( "\n" );
  164.              //continue;
  165.          }
  166.          else
  167.              printf("NO\n");
  168.      }
  169.  
  170.      return ;
  171.  }

　　2. ZOJ 3209 矩阵映射DLX精确覆盖

　　给一个大矩阵和p个小矩阵，问在p个小矩阵中能否取若干个使它们覆盖整个大矩阵，并且小矩阵间两两互不覆盖。

把大矩阵分为1-n*m个小块（就是横竖切割n和m次），则题目的要求就变成了每个小块都要被一个且仅能有一个小矩阵覆盖，然后就是映射了，因为每个小矩阵能覆盖1~n*m这么多编号小块中的某些块，那么我们让每个小矩阵为1行，并设n*m列，则题目就变成p行n*m列的矩阵对其求精确覆盖了

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <queue>
  5.  #include <map>
  6.  #include <vector>
  7.  #include <string>
  8.  #include <cstring>
  9.  #include <algorithm>
  10.  #include <math.h>
  11.  
  12.  #define SIGMA_SIZE 26
  13.  #define lson rt<<1
  14.  #define rson rt<<1|1
  15.  #pragma warning ( disable : 4996 )
  16.  
  17.  using namespace std;
  18.  typedef long long LL;
  19.  inline LL LMax(LL a,LL b)      { return a>b?a:b; }
  20.  inline LL LMin(LL a,LL b)      { return a>b?b:a; }
  21.  inline int Max(int a,int b)    { return a>b?a:b; }
  22.  inline int Min(int a,int b)       { return a>b?b:a; }
  23.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  24.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  25.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  26.  const LL mod  = ;
  27.  const int inf  = 0x3f3f3f3f;
  28.  const int maxk = 1e5+;
  29.  const int maxn = 1e5;
  30.  
  31.  struct DLX {
  32.      int n, m, size, fin;
  33.      int U[maxn], D[maxn], L[maxn], R[maxn]; //上下左右
  34.      int head[maxn], S[maxn];                //分别存每一行第一个1的点的标号和每一列1的个数
  35.      int row[maxn], col[maxn], ans[maxn];    //row,col表示第size个点在哪一行/列
  36.  
  37.      void init( int _n, int _m )
  38.      {
  39.          n = _n; m = _m;
  40.          for ( int i = ; i <= m; i++ )    //初始化第一行（人为增加的虚拟行）
  41.          {
  42.              S[i] = ;
  43.              U[i] = D[i] = i;
  44.              L[i] = i-;
  45.              R[i] = i+;
  46.          }
  47.          R[m] = ; L[] = m;        //第一行的最后一个元素指向第一个
  48.          fin = -; size = m;                //从m开始以后都是普通节点
  49.          memset( head, -, sizeof(head) );
  50.      }
  51.  
  52.      void link( int r, int c )
  53.      {
  54.          size++;                    //得到新的点标号
  55.          col[size] = c;            //第size个点在第c列
  56.          row[size] = r;            //第size个点在第r行
  57.          S[c]++;                    //第c列1的个数+1
  58.  
  59.          //组成一个环，和下面左右一样的插法
  60.          D[size] = D[c];
  61.          U[size] = c;
  62.          U[D[c]] = size;
  63.          D[c] = size;        
  64.  
  65.          //如果该行没有为1的节点
  66.          if ( head[r] <  ) head[r] = L[size] = R[size] = size;
  67.          else
  68.          {
  69.              //组成一个环,插在head[r]和head[r]右边那个元素中间
  70.              R[size] = R[head[r]];
  71.              L[R[size]] = size;
  72.              L[size] = head[r];
  73.              R[head[r]] = size;
  74.          }
  75.      }
  76.  
  77.      void remove( int c )   //删除列c及其所在行
  78.      {
  79.          L[R[c]] = L[c]; R[L[c]] = R[c];                //c的左右两个节点互相连接
  80.          for ( int i = D[c]; i != c; i = D[i] )        //屏蔽c列
  81.              for ( int j = R[i]; j != i; j = R[j] )
  82.              {
  83.                  U[D[j]] = U[j];
  84.                  D[U[j]] = D[j];
  85.                  --S[col[j]];        //j所在的列的1的数目数减少
  86.              }
  87.      }
  88.  
  89.      void resume( int c )
  90.      {
  91.          for ( int i = U[c]; i != c; i = U[i] )
  92.              for ( int j = L[i]; j != i; j = L[j] )
  93.              {
  94.                  U[D[j]] = D[U[j]] = j;
  95.                  ++S[col[j]];
  96.              }
  97.          L[R[c]] = R[L[c]] = c;
  98.      }
  99.  
  100.      void dance( int d )
  101.      {
  102.          if ( fin != - && fin <= d )
  103.              return;
  104.          if ( R[] ==  ) //第0行没有节点
  105.          {
  106.              fin = d;
  107.              return;
  108.          }
  109.  
  110.          //找出含1数目最小的一列
  111.          int mark = R[];
  112.          for ( int i = R[]; i != ; i = R[i] )
  113.              if ( S[i] < S[mark] )
  114.                  mark = i;
  115.  
  116.          remove(mark);    //移除列mark的1的对应行
  117.          for ( int i = D[mark]; i != mark; i = D[i] )
  118.          {
  119.              ans[d] = row[i];
  120.              //移除该行的1的对应列
  121.              for ( int j = R[i]; j != i; j = R[j] )
  122.                  remove(col[j]);
  123.  
  124.              dance(d+);
  125.  
  126.              //倒着恢复
  127.              for ( int j = L[i]; j != i; j = L[j] )
  128.                  resume(col[j]);
  129.          }
  130.          resume(mark);
  131.  
  132.          return;
  133.      }
  134.  }dlx;
  135.  
  136.  int pos[][];
  137.  
  138.  int main()
  139.  {
  140.      freopen("F:\\cpp\\test.txt","r",stdin); 
  141.  
  142.      int n, m, p;
  143.      int x1, x2, y1, y2;
  144.      int T; cin >> T;
  145.      while (T--)
  146.      {
  147.          scanf("%d %d %d", &n, &m, &p);
  148.          dlx.init(p, n*m);
  149.  
  150.          int id = ;
  151.          for ( int i = ; i <= n; i++ )
  152.              for ( int j = ; j <= m; j++ )
  153.                  pos[i][j] = id++;
  154.  
  155.          for ( int r = ; r <= p; r++ )
  156.          {
  157.              scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
  158.              //注意对应的规则
  159.              for ( int i = x1+; i <= x2; i++ )
  160.                  for ( int j = y1+; j <= y2; j++ )
  161.                      dlx.link( r, pos[i][j] );
  162.          }
  163.  
  164.          dlx.dance();
  165.          printf("%d\n", dlx.fin);
  166.      }
  167.  
  168.      return ;
  169.  }

懒得修改了...直接贴另一种返回

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <queue>
  5.  #include <map>
  6.  #include <vector>
  7.  #include <string>
  8.  #include <cstring>
  9.  #include <algorithm>
  10.  #include <math.h>
  11.  
  12.  #define SIGMA_SIZE 26
  13.  #define lson rt<<1
  14.  #define rson rt<<1|1
  15.  #pragma warning ( disable : 4996 )
  16.  
  17.  using namespace std;
  18.  typedef long long LL;
  19.  inline LL LMax(LL a,LL b)      { return a>b?a:b; }
  20.  inline LL LMin(LL a,LL b)      { return a>b?b:a; }
  21.  inline int Max(int a,int b)    { return a>b?a:b; }
  22.  inline int Min(int a,int b)       { return a>b?b:a; }
  23.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  24.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  25.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  26.  const LL mod  = ;
  27.  const int inf  = 0x3f3f3f3f;
  28.  const int maxk = 1e5+;
  29.  const int maxn = 1e5;
  30.  
  31.  struct DLX {
  32.      int n, m, size, fin;
  33.      int U[maxn], D[maxn], L[maxn], R[maxn]; //上下左右
  34.      int head[maxn], S[maxn];                //分别存每一行第一个1的点的标号和每一列1的个数
  35.      int row[maxn], col[maxn], ans[maxn];    //row,col表示第size个点在哪一行/列
  36.  
  37.      void init( int _n, int _m )
  38.      {
  39.          n = _n; m = _m;
  40.          for ( int i = ; i <= m; i++ )    //初始化第一行（人为增加的虚拟行）
  41.          {
  42.              S[i] = ;
  43.              U[i] = D[i] = i;
  44.              L[i] = i-;
  45.              R[i] = i+;
  46.          }
  47.          R[m] = ; L[] = m;        //第一行的最后一个元素指向第一个
  48.          fin = -; size = m;                //从m开始以后都是普通节点
  49.          memset( head, -, sizeof(head) );
  50.      }
  51.  
  52.      void link( int r, int c )
  53.      {
  54.          size++;                    //得到新的点标号
  55.          col[size] = c;            //第size个点在第c列
  56.          row[size] = r;            //第size个点在第r行
  57.          S[c]++;                    //第c列1的个数+1
  58.  
  59.          //组成一个环，和下面左右一样的插法
  60.          D[size] = D[c];
  61.          U[size] = c;
  62.          U[D[c]] = size;
  63.          D[c] = size;        
  64.  
  65.          //如果该行没有为1的节点
  66.          if ( head[r] <  ) head[r] = L[size] = R[size] = size;
  67.          else
  68.          {
  69.              //组成一个环,插在head[r]和head[r]右边那个元素中间
  70.              R[size] = R[head[r]];
  71.              L[R[size]] = size;
  72.              L[size] = head[r];
  73.              R[head[r]] = size;
  74.          }
  75.      }
  76.  
  77.      void remove( int c )   //删除列c及其所在行
  78.      {
  79.          L[R[c]] = L[c]; R[L[c]] = R[c];                //c的左右两个节点互相连接
  80.          for ( int i = D[c]; i != c; i = D[i] )        //屏蔽c列
  81.              for ( int j = R[i]; j != i; j = R[j] )
  82.              {
  83.                  U[D[j]] = U[j];
  84.                  D[U[j]] = D[j];
  85.                  --S[col[j]];        //j所在的列的1的数目数减少
  86.              }
  87.      }
  88.  
  89.      void resume( int c )
  90.      {
  91.          for ( int i = U[c]; i != c; i = U[i] )
  92.              for ( int j = L[i]; j != i; j = L[j] )
  93.              {
  94.                  U[D[j]] = D[U[j]] = j;
  95.                  ++S[col[j]];
  96.              }
  97.          L[R[c]] = R[L[c]] = c;
  98.      }
  99.  
  100.      bool dance( int d )
  101.      {
  102.          if ( fin != - && fin <= d )
  103.              return false;
  104.          if ( R[] ==  ) //第0行没有节点
  105.          {
  106.              fin = d;
  107.              return true;
  108.          }
  109.  
  110.          //找出含1数目最小的一列
  111.          int mark = R[];
  112.          for ( int i = R[]; i != ; i = R[i] )
  113.              if ( S[i] < S[mark] )
  114.                  mark = i;
  115.  
  116.          remove(mark);    //移除列mark的1的对应行
  117.          for ( int i = D[mark]; i != mark; i = D[i] )
  118.          {
  119.              ans[d] = row[i];
  120.              //移除该行的1的对应列
  121.              for ( int j = R[i]; j != i; j = R[j] )
  122.                  remove(col[j]);
  123.  
  124.              dance(d+);
  125.  
  126.              //倒着恢复
  127.              for ( int j = L[i]; j != i; j = L[j] )
  128.                  resume(col[j]);
  129.          }
  130.          resume(mark);
  131.  
  132.          return false;
  133.      }
  134.  }dlx;
  135.  
  136.  int pos[][];
  137.  
  138.  int main()
  139.  {
  140.      freopen("F:\\cpp\\test.txt","r",stdin); 
  141.  
  142.      int n, m, p;
  143.      int x1, x2, y1, y2;
  144.      int T; cin >> T;
  145.      while (T--)
  146.      {
  147.          scanf("%d %d %d", &n, &m, &p);
  148.          dlx.init(p, n*m);
  149.  
  150.          int id = ;
  151.          for ( int i = ; i <= n; i++ )
  152.              for ( int j = ; j <= m; j++ )
  153.                  pos[i][j] = id++;
  154.  
  155.          for ( int r = ; r <= p; r++ )
  156.          {
  157.              scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
  158.              //注意对应的规则
  159.              for ( int i = x1+; i <= x2; i++ )
  160.                  for ( int j = y1+; j <= y2; j++ )
  161.                      dlx.link( r, pos[i][j] );
  162.          }
  163.  
  164.          dlx.dance();
  165.          printf("%d\n", dlx.fin);
  166.      }
  167.  
  168.      return ;
  169.  }

　　3.HDU 2295 圆形重复覆盖+二分

　　一脸懵逼逼逼....如果说之前那个模板还勉强看的懂...这个就完全懵逼了（还非常容易写错）。题目比较简单就不说了

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <queue>
  5.  #include <map>
  6.  #include <vector>
  7.  #include <string>
  8.  #include <cstring>
  9.  #include <algorithm>
  10.  #include <math.h>
  11.  
  12.  #define SIGMA_SIZE 26
  13.  #define lson rt<<1
  14.  #define rson rt<<1|1
  15.  #pragma warning ( disable : 4996 )
  16.  
  17.  using namespace std;
  18.  typedef long long LL;
  19.  inline LL LMax(LL a,LL b)      { return a>b?a:b; }
  20.  inline LL LMin(LL a,LL b)      { return a>b?b:a; }
  21.  inline int Max(int a,int b)    { return a>b?a:b; }
  22.  inline int Min(int a,int b)       { return a>b?b:a; }
  23.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  24.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  25.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  26.  const LL mod  = ;
  27.  const double eps = 1e-;
  28.  const int inf  = 0x3f3f3f3f;
  29.  const int maxk = 1e4;
  30.  const int maxn = ;
  31.  
  32.  struct DLX {
  33.      int n, m, size, fin;
  34.      int U[maxk], D[maxk], L[maxk], R[maxk];
  35.      int C[maxk];
  36.  
  37.      int head[maxk];
  38.      int S[maxk];
  39.      bool vis[maxk];
  40.  
  41.      void init( int _n, int _m )
  42.      {
  43.          n = _n; m = _m;
  44.          for ( int i = ; i <= m; i++ )
  45.          {
  46.              U[i] = D[i] = i;
  47.              L[i] = i-;
  48.              R[i] = i+;
  49.              S[i] = ;
  50.          }
  51.          L[] = m; R[m] = ;
  52.          size = m;
  53.          memset( head, -, sizeof(head) );
  54.      }
  55.  
  56.      void link( int r, int c )
  57.      {
  58.          size++;
  59.          C[size] = c;
  60.          S[c]++;
  61.  
  62.          D[size] = D[c];
  63.          U[size] = c;
  64.          U[D[c]] = size;
  65.          D[c] = size;
  66.  
  67.          if ( head[r] <  )
  68.              head[r] = L[size] = R[size] = size;
  69.          else
  70.          {
  71.              R[size] = R[head[r]];
  72.              L[R[size]] = size;
  73.              L[size] = head[r];
  74.              R[head[r]] = size;
  75.          }
  76.      }
  77.  
  78.      void remove( int id )
  79.      {
  80.          for ( int i = D[id]; i != id; i = D[i] )
  81.          {
  82.              L[R[i]] = L[i];
  83.              R[L[i]] = R[i];
  84.          }
  85.      }
  86.  
  87.      void resume( int id )
  88.      {
  89.          for ( int i = D[id]; i != id; i = D[i] )
  90.              L[R[i]] = R[L[i]] = i;
  91.      }
  92.  
  93.      int h()
  94.      {
  95.          int sum = ;
  96.          memset( vis, , sizeof(vis) );
  97.          for ( int i = R[]; i != ; i = R[i] )
  98.              if (!vis[i])
  99.              {
  100.                  sum++;
  101.                  for ( int j = D[i]; j != i; j = D[j] )
  102.                      for ( int k = R[j]; k != j; k = R[k] )
  103.                          vis[C[k]] = ;
  104.              }
  105.          return sum;
  106.      }
  107.  
  108.      void dance( int k )
  109.      {
  110.          int mark, mmin = inf;
  111.          if ( k + h() >= fin )
  112.              return;
  113.          if ( R[] ==  )
  114.          {
  115.              if ( k < fin )
  116.                  fin = k;
  117.              return;
  118.          }
  119.  
  120.          for ( int i = R[]; i != ; i = R[i] )
  121.              if ( mmin > S[i] )
  122.              {
  123.                  mmin = S[i];
  124.                  mark = i;
  125.              }
  126.  
  127.          for ( int i = D[mark]; i != mark; i = D[i] )
  128.          {
  129.              remove(i);
  130.              for ( int j = R[i]; j != i; j = R[j] ) remove(j);
  131.              dance(k+);
  132.              for ( int j = R[i]; j != i; j = R[j] ) resume(j);
  133.              resume(i);
  134.          }
  135.      }
  136.  }dlx;
  137.  
  138.  double mmap[maxn][];
  139.  double cir[maxn][];
  140.  
  141.  void init( int n, int m )
  142.  {
  143.      for ( int i = ; i <= n; i++ )
  144.          scanf("%lf %lf", &mmap[i][], &mmap[i][]);
  145.      for ( int i = ; i <= m; i++ )
  146.          scanf("%lf %lf", &cir[i][], &cir[i][]);
  147.  }
  148.  
  149.  double getdis( int i, int j )
  150.  {
  151.      double a = mmap[i][] - cir[j][];
  152.      double b = mmap[i][] - cir[j][];
  153.      a *= a; b *= b;
  154.      return sqrt(a+b);
  155.  }
  156.  
  157.  bool judge( int n, int m, int k, double r )
  158.  {
  159.      dlx.init(m, n); dlx.fin = inf;
  160.  
  161.      for ( int i = ; i <= n; i++ )
  162.          for ( int j = ; j <= m; j++ )
  163.          {
  164.              if ( r >= getdis(i,j) )
  165.                  dlx.link(j,i);
  166.          }
  167.      dlx.dance();
  168.      if ( dlx.fin <= k ) return ;
  169.      else return ;
  170.  }
  171.  
  172.  int main()
  173.  {
  174.  #ifdef local
  175.      freopen("F:\\cpp\\test.txt","r",stdin);
  176.  #endif
  177.  
  178.      int n, m, k;
  179.      int T; cin >> T;
  180.      while (T--)
  181.      {
  182.          scanf("%d %d %d", &n, &m, &k);
  183.          init(n,m);
  184.  
  185.          double mid, lhs = 0.0, rhs = 1000.0;
  186.          while ( rhs - lhs > eps )
  187.          {
  188.              mid = (lhs+rhs) / ;
  189.              if ( judge(n,m,k,mid) )
  190.                  rhs = mid;
  191.              else
  192.                  lhs = mid;
  193.          }
  194.          printf("%.6lf\n", (lhs+rhs)/);
  195.      }
  196.      return ;
  197.  }

　　4.FZU 1686 矩形重复覆盖

　　原来DLX主要是考察建模啊，模板实在不想每次都打一遍了...直接ctrl+c

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <queue>
  5.  #include <map>
  6.  #include <vector>
  7.  #include <string>
  8.  #include <cstring>
  9.  #include <algorithm>
  10.  #include <math.h>
  11.  
  12.  #define SIGMA_SIZE 26
  13.  #define lson rt<<1
  14.  #define rson rt<<1|1
  15.  #pragma warning ( disable : 4996 )
  16.  
  17.  using namespace std;
  18.  typedef long long LL;
  19.  inline LL LMax(LL a,LL b)      { return a>b?a:b; }
  20.  inline LL LMin(LL a,LL b)      { return a>b?b:a; }
  21.  inline int Max(int a,int b)    { return a>b?a:b; }
  22.  inline int Min(int a,int b)       { return a>b?b:a; }
  23.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  24.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  25.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  26.  const LL mod  = ;
  27.  const double eps = 1e-;
  28.  const int inf  = 0x3f3f3f3f;
  29.  const int maxk = ;
  30.  const int maxn = ;
  31.  
  32.  struct DLX {
  33.      int n, m, size, fin;
  34.      int U[maxk], D[maxk], L[maxk], R[maxk];
  35.      int C[maxk];
  36.  
  37.      int head[maxk];
  38.      int S[maxk];
  39.      bool vis[maxk];
  40.  
  41.      void init( int _n, int _m )
  42.      {
  43.          n = _n; m = _m;
  44.          for ( int i = ; i <= m; i++ )
  45.          {
  46.              U[i] = D[i] = i;
  47.              L[i] = i-;
  48.              R[i] = i+;
  49.              S[i] = ;
  50.          }
  51.          L[] = m; R[m] = ;
  52.          fin = inf; size = m;
  53.          memset( head, -, sizeof(head) );
  54.      }
  55.  
  56.      void link( int r, int c )
  57.      {
  58.          size++;
  59.          C[size] = c;
  60.          S[c]++;
  61.  
  62.          D[size] = D[c];
  63.          U[size] = c;
  64.          U[D[c]] = size;
  65.          D[c] = size;
  66.  
  67.          if ( head[r] <  )
  68.              head[r] = L[size] = R[size] = size;
  69.          else
  70.          {
  71.              R[size] = R[head[r]];
  72.              L[R[size]] = size;
  73.              L[size] = head[r];
  74.              R[head[r]] = size;
  75.          }
  76.      }
  77.  
  78.      void remove( int id )
  79.      {
  80.          for ( int i = D[id]; i != id; i = D[i] )
  81.          {
  82.              L[R[i]] = L[i];
  83.              R[L[i]] = R[i];
  84.          }
  85.      }
  86.  
  87.      void resume( int id )
  88.      {
  89.          for ( int i = D[id]; i != id; i = D[i] )
  90.              L[R[i]] = R[L[i]] = i;
  91.      }
  92.  
  93.      int h()
  94.      {
  95.          int sum = ;
  96.          memset( vis, , sizeof(vis) );
  97.          for ( int i = R[]; i != ; i = R[i] )
  98.              if (!vis[i])
  99.              {
  100.                  sum++;
  101.                  for ( int j = D[i]; j != i; j = D[j] )
  102.                      for ( int k = R[j]; k != j; k = R[k] )
  103.                          vis[C[k]] = ;
  104.              }
  105.          return sum;
  106.      }
  107.  
  108.      void dance( int k )
  109.      {
  110.          int mark, mmin = inf;
  111.          if ( k + h() >= fin )
  112.              return;
  113.          if ( R[] ==  )
  114.          {
  115.              if ( k < fin )
  116.                  fin = k;
  117.              return;
  118.          }
  119.  
  120.          for ( int i = R[]; i != ; i = R[i] )
  121.              if ( mmin > S[i] )
  122.              {
  123.                  mmin = S[i];
  124.                  mark = i;
  125.              }
  126.  
  127.          for ( int i = D[mark]; i != mark; i = D[i] )
  128.          {
  129.              remove(i);
  130.              for ( int j = R[i]; j != i; j = R[j] ) remove(j);
  131.              dance(k+);
  132.              for ( int j = R[i]; j != i; j = R[j] ) resume(j);
  133.              resume(i);
  134.          }
  135.      }
  136.  }dlx;
  137.  
  138.  int mmap[][], g[][];
  139.  
  140.  void init()
  141.  {
  142.      memset( mmap, , sizeof(mmap) );
  143.      memset( g, , sizeof(g) );
  144.  }
  145.  
  146.  int main()
  147.  {
  148.  #ifdef local
  149.      freopen("F:\\cpp\\test.txt","r",stdin);
  150.  #endif
  151.  
  152.      int R, C, r, c;
  153.      while ( ~scanf("%d %d", &R, &C) )
  154.      {
  155.          init();
  156.          int cnt = ;
  157.          for ( int i = ; i <= R; i++ )
  158.              for (int j = ; j <= C; j++)
  159.              {
  160.                  scanf("%d", &mmap[i][j]);
  161.                  if ( mmap[i][j] )
  162.                      g[i][j] = ++cnt;
  163.              }
  164.          scanf("%d %d", &r, &c);
  165.          dlx.init( (R-r+)*(C-c+), cnt ); 
  166.  
  167.          cnt = ;
  168.          for ( int i = ; i+r- <= R; i++ )
  169.              for ( int j = ; j+c- <= C; j++ )
  170.              {
  171.                  for ( int a = i; a <= i+r-; a++ )
  172.                      for ( int b = j; b <= j + c - ; b++ )
  173.                          if (g[a][b])
  174.                              dlx.link(cnt, g[a][b]);
  175.                  cnt++;
  176.              }
  177.          dlx.dance();
  178.          printf("%d\n", dlx.fin);
  179.      }
  180.  
  181.      return ;
  182.  }

　　5.POJ 3074

　　求解数独....emmmm我得好好理解下才行

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <queue>
  5.  #include <map>
  6.  #include <vector>
  7.  #include <string>
  8.  #include <cstring>
  9.  #include <algorithm>
  10.  #include <math.h>
  11.  #include <time.h>
  12.  
  13.  #define SIGMA_SIZE 26
  14.  #define lson rt<<1
  15.  #define rson rt<<1|1
  16.  #pragma warning ( disable : 4996 )
  17.  
  18.  using namespace std;
  19.  typedef long long LL;
  20.  inline LL LMax(LL a,LL b)      { return a>b?a:b; }
  21.  inline LL LMin(LL a,LL b)      { return a>b?b:a; }
  22.  inline int Max(int a,int b)    { return a>b?a:b; }
  23.  inline int Min(int a,int b)       { return a>b?b:a; }
  24.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  25.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  26.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  27.  const LL mod  = ;
  28.  const double eps = 1e-;
  29.  const int inf  = 0x3f3f3f3f;
  30.  const int maxk = 1e8;
  31.  const int maxn = ;
  32.  
  33.  struct node {
  34.      int x, y, k;
  35.  }e[];
  36.  
  37.  struct DLX {
  38.      int n, m, size, fin;
  39.      int U[maxn], D[maxn], L[maxn], R[maxn];//上下左右
  40.      int head[maxn], S[maxn];                //分别存每一行第一个1的点的标号和每一列1的个数
  41.      int row[maxn], col[maxn], ans[maxn];    //row,col表示第size个点在哪一行/列
  42.  
  43.      void init( int _n, int _m )
  44.      {
  45.          n = _n; m = _m;
  46.          for ( int i = ; i <= m; i++ )    //初始化第一行（人为增加的虚拟行）
  47.          {
  48.              S[i] = ;
  49.              U[i] = D[i] = i;
  50.              L[i] = i-;
  51.              R[i] = i+;
  52.          }
  53.          R[m] = ; L[] = m;        //第一行的最后一个元素指向第一个
  54.          size = m;                //从m开始以后都是普通节点
  55.          memset( head, -, sizeof(head) );
  56.          head[] = ;
  57.      }
  58.  
  59.      void link( int r, int c )
  60.      {
  61.          size++;                    //得到新的点标号
  62.          col[size] = c;            //第size个点在第c列
  63.          row[size] = r;            //第size个点在第r行
  64.          S[c]++;                    //第c列1的个数+1
  65.  
  66.                                     //组成一个环，和下面左右一样的插法
  67.          D[size] = D[c];
  68.          U[size] = c;
  69.          U[D[c]] = size;
  70.          D[c] = size;        
  71.  
  72.          //如果该行没有为1的节点
  73.          if ( head[r] <  ) head[r] = L[size] = R[size] = size;
  74.          else
  75.          {
  76.              //组成一个环,插在head[r]和head[r]右边那个元素中间
  77.              R[size] = R[head[r]];
  78.              L[R[size]] = size;
  79.              L[size] = head[r];
  80.              R[head[r]] = size;
  81.          }
  82.      }
  83.  
  84.      void remove( int c )   //删除列c及其所在行
  85.      {
  86.          L[R[c]] = L[c]; R[L[c]] = R[c];                //c的左右两个节点互相连接
  87.          for ( int i = D[c]; i != c; i = D[i] )        //屏蔽c列
  88.              for ( int j = R[i]; j != i; j = R[j] )
  89.              {
  90.                  U[D[j]] = U[j];
  91.                  D[U[j]] = D[j];
  92.                  --S[col[j]];        //j所在的列的1的数目数减少
  93.              }
  94.      }
  95.  
  96.      void resume( int c )
  97.      {
  98.          for ( int i = U[c]; i != c; i = U[i] )
  99.              for ( int j = L[i]; j != i; j = L[j] )
  100.              {
  101.                  U[D[j]] = D[U[j]] = j;
  102.                  ++S[col[j]];
  103.              }
  104.          L[R[c]] = R[L[c]] = c;
  105.      }
  106.  
  107.      bool dance( int d )
  108.      {
  109.          if ( R[] ==  ) //第0行没有节点
  110.          {
  111.              fin = d;
  112.              return true;
  113.          }
  114.  
  115.          //找出含1数目最小的一列
  116.          int mark = R[];
  117.          for ( int i = R[]; i != ; i = R[i] )
  118.              if ( S[i] < S[mark] )
  119.                  mark = i;
  120.  
  121.          remove(mark);    //移除列mark的1的对应行
  122.          for ( int i = D[mark]; i != mark; i = D[i] )
  123.          {
  124.              ans[d] = row[i];
  125.              //移除该行的1的对应列
  126.              for ( int j = R[i]; j != i; j = R[j] )
  127.                  remove(col[j]);
  128.  
  129.              if ( dance(d+) )
  130.                  return true;
  131.  
  132.              //倒着恢复
  133.              for ( int j = L[i]; j != i; j = L[j] )
  134.                  resume(col[j]);
  135.          }
  136.          resume(mark);
  137.          return false;
  138.      }
  139.  }dlx;
  140.  
  141.  int mmap[][];
  142.  char sudoku[];
  143.  
  144.  void read()
  145.  {
  146.      dlx.init(,);
  147.      int row = ;
  148.  
  149.      for ( int i = ; i <= ; i++ )
  150.          for ( int j = ; j <= ; j++ )
  151.          {
  152.              if ( !mmap[i][j] )
  153.              {
  154.                  for ( int k = ; k <= ; k++ )
  155.                  {
  156.                      ++row;
  157.                      dlx.link(row, (i-)*+j);
  158.                      dlx.link(row, +(i-)*+k);
  159.                      dlx.link(row, +(j-)*+k);
  160.                      dlx.link(row,+(((i-)/)*+(j+)/-)*+k);
  161.                      e[row].x = i; e[row].y = j; e[row].k = k;
  162.                  }
  163.              }
  164.              else
  165.              {
  166.                  ++row;
  167.                  int k = mmap[i][j];
  168.                  dlx.link(row, (i-)*+j);
  169.                  dlx.link(row, +(i-)*+k);
  170.                  dlx.link(row, +(j-)*+k);
  171.                  dlx.link(row, +(((i-)/)*+(j+)/-)*+k);
  172.                  e[row].x = i; e[row].y = j; e[row].k = k;
  173.              }
  174.          }
  175.  
  176.  }
  177.  
  178.  void init()
  179.  {
  180.      int t = ;
  181.  
  182.      for ( int i = ; i <= ; i++ )
  183.          for ( int j = ; j <= ; j++ )
  184.          {
  185.              if ( sudoku[++t] != '.' )
  186.                  mmap[i][j] = sudoku[t] - '';
  187.              else
  188.                  mmap[i][j] = ;
  189.          }
  190.  
  191.      read();
  192.  }
  193.  
  194.  int main()
  195.  {
  196.      //freopen("F:\\cpp\\test.txt", "r", stdin );
  197.  
  198.      while ( ~scanf("%s", sudoku+) )
  199.      {
  200.          if (sudoku[] == 'e') break;
  201.          init();
  202.  
  203.          dlx.dance();
  204.          for ( int i = ; i < dlx.fin; i++ )
  205.          {
  206.              int tmp = dlx.ans[i];
  207.              sudoku[(e[tmp].x-)* + e[tmp].y-] = ''+e[tmp].k;
  208.          }
  209.          sudoku[dlx.fin] = '\0';
  210.          printf("%s\n", sudoku);
  211.      }
  212.  
  213.      return ;
  214.  }

　　6. HDU 5046

　　和hdu2295基本一样，有个可以优化的方法是将可行的距离排序后二分下标，如果不这样做直接二分，左右区间要到1~4e9才行，而且大概率TLE（交了一发1300ms）

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <queue>
  5.  #include <map>
  6.  #include <vector>
  7.  #include <string>
  8.  #include <cstring>
  9.  #include <algorithm>
  10.  #include <math.h>
  11.  #include <time.h>
  12.  
  13.  #define SIGMA_SIZE 26
  14.  #define lson rt<<1
  15.  #define rson rt<<1|1
  16.  #pragma warning ( disable : 4996 )
  17.  
  18.  using namespace std;
  19.  typedef long long LL;
  20.  inline LL LMax(LL a,LL b)      { return a>b?a:b; }
  21.  inline LL LMin(LL a,LL b)      { return a>b?b:a; }
  22.  inline int Max(int a,int b)    { return a>b?a:b; }
  23.  inline int Min(int a,int b)       { return a>b?b:a; }
  24.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  25.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  26.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  27.  const LL mod  = ;
  28.  const double eps = 1e-;
  29.  const int inf  = 0x3f3f3f3f;
  30.  const int maxk = ;
  31.  const int maxn = ;
  32.  
  33.  int N, K;
  34.  
  35.  struct DLX {
  36.      int n, m, size, fin;
  37.      int U[maxk], D[maxk], L[maxk], R[maxk];
  38.      int C[maxk];
  39.  
  40.      int head[];
  41.      int S[];
  42.      bool vis[maxk];
  43.  
  44.      void init( int _n, int _m )
  45.      {
  46.          n = _n; m = _m;
  47.          for ( int i = ; i <= m; i++ )
  48.          {
  49.              U[i] = D[i] = i;
  50.              L[i] = i-;
  51.              R[i] = i+;
  52.              S[i] = ;
  53.          }
  54.          L[] = m; R[m] = ;
  55.          size = m;
  56.          memset( head, -, sizeof(head) );
  57.      }
  58.  
  59.      void link( int r, int c )
  60.      {
  61.          size++;
  62.          C[size] = c;
  63.          S[c]++;
  64.  
  65.          D[size] = D[c];
  66.          U[size] = c;
  67.          U[D[c]] = size;
  68.          D[c] = size;
  69.  
  70.          if ( head[r] <  )
  71.              head[r] = L[size] = R[size] = size;
  72.          else
  73.          {
  74.              R[size] = R[head[r]];
  75.              L[R[size]] = size;
  76.              L[size] = head[r];
  77.              R[head[r]] = size;
  78.          }
  79.      }
  80.  
  81.      void remove( int id )
  82.      {
  83.          for ( int i = D[id]; i != id; i = D[i] )
  84.          {
  85.              L[R[i]] = L[i];
  86.              R[L[i]] = R[i];
  87.          }
  88.      }
  89.  
  90.      void resume( int id )
  91.      {
  92.          for ( int i = D[id]; i != id; i = D[i] )
  93.              L[R[i]] = R[L[i]] = i;
  94.      }
  95.  
  96.      int h()
  97.      {
  98.          int sum = ;
  99.          memset( vis, , sizeof(vis) );
  100.          for ( int i = R[]; i != ; i = R[i] )
  101.              if (!vis[i])
  102.              {
  103.                  sum++;
  104.                  for ( int j = D[i]; j != i; j = D[j] )
  105.                      for ( int k = R[j]; k != j; k = R[k] )
  106.                          vis[C[k]] = ;
  107.              }
  108.          return sum;
  109.      }
  110.  
  111.      void dance( int k )
  112.      {
  113.          int mark, mmin = inf;
  114.          int tmp = k + h();
  115.          if ( tmp >= fin || tmp > K )
  116.              return;
  117.          if ( R[] ==  )
  118.          {
  119.              if ( k < fin )
  120.                  fin = k;
  121.              return;
  122.          }
  123.  
  124.          for ( int i = R[]; i != ; i = R[i] )
  125.              if ( mmin > S[i] )
  126.              {
  127.                  mmin = S[i];
  128.                  mark = i;
  129.              }
  130.  
  131.          for ( int i = D[mark]; i != mark; i = D[i] )
  132.          {
  133.              remove(i);
  134.              for ( int j = R[i]; j != i; j = R[j] ) remove(j);
  135.              dance(k+);
  136.              for ( int j = R[i]; j != i; j = R[j] ) resume(j);
  137.              resume(i);
  138.          }
  139.      }
  140.  }dlx;
  141.  
  142.  int cnt;
  143.  int g[][];
  144.  
  145.  struct mmap {
  146.      int x, y;
  147.      LL dist;
  148.      bool operator < ( const mmap &a ) const
  149.          { return dist < a.dist; }
  150.  }node[*];
  151.  
  152.  LL getdist( int i, int j )
  153.  {
  154.      LL x = abs(g[i][]-g[j][]);
  155.      LL y = abs(g[i][]-g[j][]);
  156.      return x+y;
  157.  }
  158.  
  159.  void init( int n )
  160.  {
  161.      cnt = ;
  162.      for( int i = ; i <= n; i++ )
  163.          scanf("%d %d", &g[i][], &g[i][] );
  164.      for ( int i = ; i <= n; i++ )
  165.          for ( int j = i; j <= n; j++ )
  166.          {
  167.              node[cnt].x = i; node[cnt].y = j;
  168.              node[cnt++].dist = getdist(i,j);
  169.          }
  170.      sort(node, node+cnt);
  171.  }
  172.  
  173.  bool judge( int n, int k, LL mid )
  174.  {
  175.      dlx.init(n, n); dlx.fin = k+;
  176.  
  177.      for ( int i = ; i < cnt; i++ )
  178.      {
  179.          if ( node[i].dist > mid ) break;
  180.  
  181.          dlx.link( node[i].x, node[i].y );
  182.          if ( node[i].x != node[i].y )
  183.              dlx.link( node[i].y, node[i].x );
  184.      }
  185.  
  186.      dlx.dance();
  187.      if ( dlx.fin <= k )
  188.          return true;
  189.      else
  190.          return false;
  191.  }
  192.  
  193.  LL solve( int n, int k )
  194.  {
  195.      LL mid, lhs = , rhs = cnt;
  196.      while ( lhs <= rhs )
  197.      {
  198.          mid = (lhs+rhs)>>;
  199.          if ( judge(n,k,node[mid].dist) )
  200.              rhs = mid-;
  201.          else
  202.              lhs = mid+;
  203.      }
  204.  
  205.      if ( judge(n,k,node[lhs].dist) )
  206.          return node[lhs].dist;
  207.      else
  208.          return node[rhs].dist;
  209.  }
  210.  
  211.  int main()
  212.  {
  213.      //freopen("F:\\cpp\\test.txt", "r", stdin );
  214.  
  215.      int T; cin >> T;
  216.      int n, k, cnt = ;
  217.      while (T--)
  218.      {
  219.          scanf("%d %d", &n, &k);
  220.          N = n; K = k;
  221.          init(n);
  222.          printf("Case #%d: %lld\n", cnt++, solve(n,k));
  223.      }
  224.  
  225.      return ;
  226.  }

　　7.ZOJ 3122

　　16个数字的数独，和9个数字的数独其实一样，这次加了注释，终于理解了...然后dlx范围老是调不好

  1.  #include <iostream>
  2.  #include <string.h>
  3.  #include <cstdio>
  4.  #include <vector>
  5.  #include <string>
  6.  #include <algorithm>
  7.  #include <math.h>
  8.  #include <time.h>
  9.  
  10.  #define SIGMA_SIZE 26
  11.  #define lson rt<<1
  12.  #define rson rt<<1|1
  13.  #pragma warning ( disable : 4996 )
  14.  
  15.  using namespace std;
  16.  typedef long long LL;
  17.  inline LL LMax(LL a,LL b)      { return a>b?a:b; }
  18.  inline LL LMin(LL a,LL b)      { return a>b?b:a; }
  19.  inline int Max(int a,int b)    { return a>b?a:b; }
  20.  inline int Min(int a,int b)       { return a>b?b:a; }
  21.  inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
  22.  inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
  23.  const LL INF = 0x3f3f3f3f3f3f3f3f;
  24.  const LL mod  = ;
  25.  const double eps = 1e-;
  26.  const int inf  = 0x3f3f3f3f;
  27.  const int maxk = 1e5;
  28.  const int maxn = ;
  29.  
  30.  //行：16x16x16=4096表示每个格子有16种选择
  31.  //列：(16x16)x3=768，表示16行16列16小块每个各有16种数字单独存在
  32.  //列：还要加上768+16x16=1024，表示每个格子只能有一个数字
  33.  
  34.  struct DLX {
  35.      int n, m, size, fin;
  36.      int U[maxk], D[maxk], L[maxk], R[maxk];//上下左右
  37.      int head[maxk], S[maxk];                //分别存每一行第一个1的点的标号和每一列1的个数
  38.      int row[maxk], col[maxk], ans[maxk];    //row,col表示第size个点在哪一行/列
  39.  
  40.      void init( int _n, int _m )
  41.      {
  42.          n = _n; m = _m;
  43.          for ( int i = ; i <= m; i++ )    //初始化第一行（人为增加的虚拟行）
  44.          {
  45.              S[i] = ;
  46.              U[i] = D[i] = i;
  47.              L[i] = i-;
  48.              R[i] = i+;
  49.          }
  50.          R[m] = ; L[] = m;        //第一行的最后一个元素指向第一个
  51.          size = m;                //从m开始以后都是普通节点
  52.          memset( head, -, sizeof(head) );
  53.          head[] = ;
  54.      }
  55.  
  56.      void link( int r, int c )
  57.      {
  58.          size++;                    //得到新的点标号
  59.          col[size] = c;            //第size个点在第c列
  60.          row[size] = r;            //第size个点在第r行
  61.          S[c]++;                    //第c列1的个数+1
  62.  
  63.                                     //组成一个环，和下面左右一样的插法
  64.          D[size] = D[c];
  65.          U[size] = c;
  66.          U[D[c]] = size;
  67.          D[c] = size;        
  68.  
  69.          //如果该行没有为1的节点
  70.          if ( head[r] <  ) head[r] = L[size] = R[size] = size;
  71.          else
  72.          {
  73.              //组成一个环,插在head[r]和head[r]右边那个元素中间
  74.              R[size] = R[head[r]];
  75.              L[R[size]] = size;
  76.              L[size] = head[r];
  77.              R[head[r]] = size;
  78.          }
  79.      }
  80.  
  81.      void remove( int c )   //删除列c及其所在行
  82.      {
  83.          L[R[c]] = L[c]; R[L[c]] = R[c];                //c的左右两个节点互相连接
  84.          for ( int i = D[c]; i != c; i = D[i] )        //屏蔽c列
  85.              for ( int j = R[i]; j != i; j = R[j] )
  86.              {
  87.                  U[D[j]] = U[j];
  88.                  D[U[j]] = D[j];
  89.                  --S[col[j]];        //j所在的列的1的数目数减少
  90.              }
  91.      }
  92.  
  93.      void resume( int c )
  94.      {
  95.          for ( int i = U[c]; i != c; i = U[i] )
  96.              for ( int j = L[i]; j != i; j = L[j] )
  97.              {
  98.                  U[D[j]] = D[U[j]] = j;
  99.                  ++S[col[j]];
  100.              }
  101.          L[R[c]] = R[L[c]] = c;
  102.      }
  103.  
  104.      bool dance( int d )
  105.      {
  106.          if ( R[] ==  ) //第0行没有节点
  107.          {
  108.              fin = d;
  109.              return true;
  110.          }
  111.  
  112.          //找出含1数目最小的一列
  113.          int mark = R[];
  114.          for ( int i = R[]; i != ; i = R[i] )
  115.              if ( S[i] < S[mark] )
  116.                  mark = i;
  117.  
  118.          remove(mark);    //移除列mark的1的对应行
  119.          for ( int i = D[mark]; i != mark; i = D[i] )
  120.          {
  121.              ans[d] = row[i];
  122.              //移除该行的1的对应列
  123.              for ( int j = R[i]; j != i; j = R[j] )
  124.                  remove(col[j]);
  125.  
  126.              if ( dance(d+) )
  127.                  return true;
  128.  
  129.              //倒着恢复
  130.              for ( int j = L[i]; j != i; j = L[j] )
  131.                  resume(col[j]);
  132.          }
  133.          resume(mark);
  134.          return false;
  135.      }
  136.  }dlx;
  137.  
  138.  char mmap[][];
  139.  char sudoku[][];
  140.  struct node {
  141.      int x, y, k;
  142.  }e[maxk];
  143.  
  144.  void init()
  145.  {
  146.      //4096行，1024列
  147.      dlx.init(,);
  148.      int row = ;
  149.  
  150.      for ( int i = ; i <= ; i++ )
  151.          for ( int j = ; j <= ; j++ )
  152.          {
  153.              if ( mmap[i][j] == '-' )
  154.                  for (int k = ; k <= ; k++ )
  155.                  {
  156.                      row++;
  157.                      dlx.link(row, (i-)*+j );                            //第i行第j个格子已经填了数字
  158.                      dlx.link(row, +(i-)*+k);                        //第i行已经填了数字k
  159.                      dlx.link(row, +(j-)*+k);                        //第j列已经填了数字k
  160.                      dlx.link(row, +(((i-)/)* + (j-)/)*+k);    //第xxx个格子已经填了数字k
  161.                      e[row].x = i; e[row].y = j; e[row].k = k;
  162.                  }
  163.              else
  164.              {
  165.                  row++;
  166.                  int k = mmap[i][j] - 'A' + ;
  167.                  dlx.link(row, (i-)*+j);
  168.                  dlx.link(row, +(i-)*+k);
  169.                  dlx.link(row, +(j-)*+k);
  170.                  dlx.link(row, +(((i-)/)* + (j-)/)*+k);
  171.                  e[row].x = i; e[row].y = j; e[row].k = k;
  172.              }
  173.          }
  174.  }
  175.  
  176.  int main()
  177.  {
  178.      //freopen("F:\\cpp\\test.txt", "r", stdin );
  179.  
  180.      int cnt = ;
  181.      while ()
  182.      {
  183.          if ( ~scanf("%s", mmap[]+) )
  184.          {
  185.              for ( int i = ; i <= ; i++ )
  186.                  scanf("%s", mmap[i]+);
  187.  
  188.              if (cnt++)
  189.                   printf("\n"); 
  190.  
  191.              init();
  192.              dlx.dance();
  193.  
  194.              int tmp;
  195.              for ( int i = ; i < dlx.fin; i++ )
  196.              {
  197.                  tmp = dlx.ans[i];
  198.                  sudoku[e[tmp].x-][e[tmp].y-] = e[tmp].k + 'A' - ;
  199.                  sudoku[e[tmp].x-][] = '\0';
  200.              }
  201.              for ( int i = ; i < ; i++ )
  202.                  printf("%s\n", sudoku[i]);
  203.          }
  204.          else
  205.              break;
  206.      }
  207.  }

kuangbin带我飞QAQ DLX之一脸懵逼的更多相关文章

  1. kuangbin带我飞QAQ 线段树

    1. HDU1166 裸线段树点修改 #include <iostream> #include <string.h> #include <cstdio> #incl ...

  2. kuangbin带我飞QAQ 并查集

    1. POJ 2236 给出N个点,一开始图是空白的,两个操作,一个是增加一个点(给出坐标),一个是查询两个点间是否相通,当两点间的距离小于D或者两点通过其他点间接相连时说这两个点相通.并查集维护,每 ...

  3. kuangbin带我飞QAQ 最短路

    1. poj 1502 Mathches Game 裸最短路 #include <iostream> #include <string.h> #include <cstd ...

  4. 一脸懵逼学习Hadoop中的序列化机制——流量求和统计MapReduce的程序开发案例——流量求和统计排序

    一:序列化概念 序列化(Serialization)是指把结构化对象转化为字节流.反序列化(Deserialization)是序列化的逆过程.即把字节流转回结构化对象.Java序列化(java.io. ...

  5. Python里面这些点，据说80%的新手都会一脸懵逼

    Python里面这些点,据说80%的新手都会一脸懵逼 菜鸟Python 关注 2018.10.10 12:51 字数 1833 阅读 123评论 0喜欢 10 Python虽然语法简单,通俗易懂,但是 ...

  6. 腾讯一面！说说ArrayList的遍历foreach与iterator时remove的区别，我一脸懵逼

    本文基于JDK-8u261源码分析 1 简介 ​ ArrayList作为最基础的集合类,其底层是使用一个动态数组来实现的,这里"动态"的意思是可以动态扩容(虽然ArrayList可 ...

  7. 一脸懵逼学习基于CentOs的Hadoop集群安装与配置

    1:Hadoop分布式计算平台是由Apache软件基金会开发的一个开源分布式计算平台.以Hadoop分布式文件系统(HDFS)和MapReduce(Google MapReduce的开源实现)为核心的 ...

  8. 一脸懵逼学习Storm---（一个开源的分布式实时计算系统）

    Storm的官方网址:http://storm.apache.org/index.html 1:什么是Storm? Storm是一个开源的分布式实时计算系统,可以简单.可靠的处理大量的数据流.被称作“ ...

  9. Java中线程同步锁和互斥锁有啥区别？看完你还是一脸懵逼？

    首先不要钻概念牛角尖,这样没意义. 也许java语法层面包装成了sycnchronized或者明确的XXXLock,但是底层都是一样的.无非就是哪种写起来方便而已. 锁就是锁而已,避免多个线程对同一个 ...

随机推荐

  1. 用星星画菱形--Java

    用星星画菱形 public class Hello{ public static void main(String[] args) { char star = '\u2605'; System.out ...

  2. JS规则 编程练习 考考大家的数学，计算以下计算公式的结果。然后在浏览器中运行一下，看看结果是否跟你的结果一致。

    编程练习 考考大家的数学,计算以下计算公式的结果.然后在浏览器中运行一下,看看结果是否跟你的结果一致. 任务 第一步: 在  ? 处填写你的答案. 第二步: 填写完成后,运行一下,看看是不是跟你填写的 ...

  3. Luogu P3033 [USACO11NOV]牛的障碍Cow Steeplechase(二分图匹配)

    P3033 [USACO11NOV]牛的障碍Cow Steeplechase 题意 题目描述 --+------- -----+----- ---+--- | | | | --+-----+--+- ...

  4. Python全栈开发：css引入方式

    css的四种引入方式: 1.行内式 行内式是在标记的style属性中设定CSS样式.这种方式没有体现出CSS的优势,不推荐使用. <p style="color: red;backgr ...

  5. [symonfy] An error occurred when executing the "'cache:clear --no-warmup'"

    Symfony Version: 3.4.* 当运行 composer update 会出现 [RuntimeException] An error occurred when executing t ...

  6. A*算法——第K短路

    例题 JZOJ senior 1163第K短路 题目描述 Bessie 来到一个小农场,有时她想回老家看看她的一位好友.她不想太早地回到老家,因为她喜欢途中的美丽风景.她决定选择K短路径,而不是最短路 ...

  7. Zuul上传文件

    对于1M以内的文件上传,无需任何处理,大文件10M以上需要为上传路径添加/zuul前缀,也可使用zuul.servlet-path自定义前缀 如果Zuul使用了Ribbon做负载均衡,那么对于超大的文 ...

  8. iframe跨域数据传递

    项目中需要和其他单位合作开发,方案采用iframe嵌入页面,开发过程中设计到了跨域数据的传递,初步方案决定使用html5 API postMessage进行iframe跨域数据传递: 域名A下的页面 ...

  9. Android之FrameLayout帧布局

    1.简介 这个布局直接在屏幕上开辟出一块空白的区域,当我们往里面添加控件的时候,会默认把他们放到这块区域的左上角; 帧布局的大小由控件中最大的子控件决定,如果控件的大小一样大的话,那么同一时刻就只能看 ...

  10. 05_springmvc参数绑定

    一.参数绑定的过程 从客户端请求key/value数据,经过参数绑定,将key/value数据绑定到controller方法的形参上.springmvc中,接收页面提交的数据是通过方法形参来接收.而不 ...