GitHub - jzplp/aoapc-UVA-Answer: 算法竞赛入门经典 例题和习题答案 刘汝佳 第二版

题目要求切断部分圆环后再链接起来成为一个链，要求切断的圆环最少。注意链不需要按照序号1-n排列，可以乱序。

我一开始的方法好像可以解决问题，但是大幅超时。方法是对每个环断开再对其它圆环每个尝试连接，试图遍历所有场景找出可以形成一条链的组合。但是这种方法产生了不少重复遍历场景（断开的先后顺序不重要），且实际上不需要尝试链接，就能判断是否组成一条链，因此这里时间复杂度太高，大幅超时了。（超时代码放到最后了）

后来参考网上的方法：

1. 遍历所有断开的圆环的组合。设有n个圆环，这里使用的是对 0 ~ (2^n - 1)进行遍历。其中给每个数字了包含了圆环是否断开的二进制数据。getBreakPoint函数是将二进制数字转换为断开的点数组。

2. breakMap函数，将断开的圆环和其它的圆环的链接删掉，组成一个新的图。因为圆环是断开后就不和所有圆环有关系了。

3. judge函数，判断 断开后的圆环组合是否符合规范。这里有几个点：

3.1. 首先看每个节点的度，如果度超过2，说明有一个点连接了超过两个点，那肯定需要再断开其他圆环才能形成链，说明这个断开组合不符合要求。

3.2. 看这个图中是否还有多个圆环组成的“环”。有的话说明再断开其他圆环才能形成链，不符合要求。判断方法是dfs遍历，遍历一条边就删掉一条边，然后看有没有点访问次数超过2。

3.3. 统计没有联通的子图的数量，设为m。设断开的圆环数量为a。如果m - 2 * a - 1 <= 0，则说明这个图符合要求，可以组成一条链。

其中3.3即是“实际上不需要尝试链接，就能判断是否组成一条链”的公式。这里来解释一下：

首先断开的圆环，是可以链接其他已有的每个连通子图的。一个断开的圆环可以链接两个子图。但是，链接两个子图后，就形成了一个新的子图。所以事实上a个断开的圆环可以链接a+1个子图。再加上断开的圆环本身也是一个子图。所以，2*a+1是可以连接的最大子图数量。如果子图数量比它要大，那就说明无法链接成一条完整的链了。

AC代码

#include <stdio.h>
#include <string.h>
#define MAXN 17

// 序号从1到n
int map[MAXN][MAXN];
int n;

// 保存当前断开场景下的图
int mapTemp[MAXN][MAXN];
// 当前断开的点
int breakPoint[MAXN];
// judge中点是否访问过
int findPoint[MAXN];

void init()
{
  memset(map, 0, sizeof(map));
}

// 复制一份图
void copyMap()
{
  int i, j;
  for (i = 1; i <= n; ++i)
    for (j = 1; j <= n; ++j)
      mapTemp[i][j] = map[i][j];
}

// 由二进制数字转换为断开的点数组
int getBreakPoint(int cnt)
{
  int i, j, k = 0;
  for (i = 0; i < n; ++i)
  {
    j = (cnt / (1 << i)) % 2;
    if (j)
      ++k;
    breakPoint[i + 1] = j;
  }
  return k;
}

// 根据断开点数组来断开图
void breakMap()
{
  int i, j;
  for (i = 1; i <= n; ++i)
  {
    if (!breakPoint[i])
      continue;
    for (j = 1; j <= n; ++j)
    {
      mapTemp[i][j] = 0;
      mapTemp[j][i] = 0;
    }
  }
}

void dfs(int point)
{
  ++findPoint[point];
  for (int j = 1; j <= n; ++j)
  {
    if (!mapTemp[point][j] || j == point)
      continue;
    // 访问过的边就删掉，避免重复访问
    // 对应的，已访问过的节点可以重复访问
    mapTemp[point][j] = 0;
    mapTemp[j][point] = 0;
    dfs(j);
  }
}

// 判断有几个链，以及是否有环
int judge()
{
  // 链数 单个节点也是链
  int linkNum = 0;
  int i, j, k;

  // 首先看每个节点的度
  for (i = 1; i <= n; ++i)
  {
    k = 0;
    for (j = 1; j <= n; ++j)
      if (mapTemp[i][j])
        ++k;
    if (k > 2)
      return -1;
  }
  // 然后看每个节点是否有环
  memset(findPoint, 0, sizeof(findPoint));
  for (i = 1; i <= n; ++i)
  {
    if (findPoint[i])
      continue;
    ++linkNum;
    dfs(i);
    for (j = 1; j <= n; ++j)
    {
      if (findPoint[j] >= 2)
        return -1;
    }
  }
  return linkNum;
}

int computed()
{
  int i, j, k;
  int breakMin = n, breakNum;
  int linkNum;
  for (i = 0; i < (1 << n); ++i)
  {
    copyMap();
    breakNum = getBreakPoint(i);
    if (breakNum >= breakMin)
      continue;
    breakMap();
    linkNum = judge();
    if (linkNum < 0)
      continue;
    if (linkNum - breakNum * 2 - 1 > 0)
      continue;
    breakMin = breakNum;
  }
  return breakMin;
}

int main()
{
  int cnt = 0;
  int i, j, sum = 0;
  while (scanf("%d", &n) == 1 && n > 0)
  {
    ++cnt;
    init();
    while (scanf("%d %d", &i, &j) == 2 && i > 0)
    {
      map[i][j] = 1;
      map[j][i] = 1;
    }
    if (n > 1)
      sum = computed();
    printf("Set %d: Minimum links to open is %d\n", cnt, sum);
  }
  return 0;
}

超时代码

#include <stdio.h>
#include <string.h>
#define MAXN 17

// 序号从1到n
int map[MAXN][MAXN];
// 每个点是否已经重新设置
int setFlag[MAXN];
// 暂存每一层中被清空绑定关系的数据
int setFlagMap[MAXN][MAXN];
int n;
int sum;
// 判断是否联通图需要的记录
int mapFlag[MAXN];

void init()
{
  memset(map, 0, sizeof(map));
  memset(setFlag, 0, sizeof(setFlag));
  memset(setFlagMap, 0, sizeof(setFlagMap));
  sum = n;
}

void dfs(int i)
{
  mapFlag[i] = 1;
  for (int j = 1; j <= n; ++j)
  {
    if (mapFlag[j] || !map[i][j])
      continue;
    dfs(j);
  }
}

// 两个端点的度为1，其余的所有点度为2
bool judge()
{
  int i, j;
  int num1 = 0, num2 = 0, count;
  for (i = 1; i <= n; ++i)
  {
    count = 0;
    for (j = 1; j <= n; ++j)
      if (map[i][j])
        ++count;
    if (count == 1)
      ++num1;
    else if (count == 2)
      ++num2;
    else
      return false;
  }
  if (num1 != 2 && num2 != n - 2)
    return false;
  // 判断是否是联通图
  memset(mapFlag, 0, sizeof(mapFlag));
  dfs(1);
  for (i = 1; i <= n; ++i)
    if (!mapFlag[i])
      return false;
  return true;
}

void computed(int cnt)
{
  if (cnt >= sum)
    return;
  if (judge())
  {
    sum = cnt;
    return;
  }
  int i, j, k;
  // 选中i作为open
  for (i = 1; i <= n; ++i)
  {
    if (setFlag[i])
      continue;
    setFlag[i] = 1;
    // 清空i的绑定关系
    memset(setFlagMap[cnt + 1], 0, MAXN * sizeof(int));
    for (j = 1; j <= n; ++j)
    {
      setFlagMap[cnt + 1][j] = map[i][j];
      map[i][j] = 0;
      map[j][i] = 0;
    }

    // 绑定一个的情况
    for (j = 1; j <= n; ++j)
    {
      if (j == i)
        continue;
      map[i][j] = 1;
      map[j][i] = 1;
      computed(cnt + 1);
      map[i][j] = 0;
      map[j][i] = 0;
    }
    // 绑定两个的情况
    for (j = 1; j <= n; ++j)
    {
      if (j == i)
        continue;
      for (k = 1; k <= n; ++k)
      {
        if (k == i || k == j)
          continue;
        map[i][j] = 1;
        map[j][i] = 1;
        map[i][k] = 1;
        map[k][i] = 1;
        computed(cnt + 1);
        map[i][j] = 0;
        map[j][i] = 0;
        map[i][k] = 0;
        map[k][i] = 0;
      }
    }

    // 恢复原有的绑定关系
    for (j = 1; j <= n; ++j)
    {
      map[i][j] = setFlagMap[cnt + 1][j];
      map[j][i] = setFlagMap[cnt + 1][j];
    }
    setFlag[i] = 0;
  }
}

void printMap()
{
  int i, j;
  for (i = 1; i <= n; ++i)
  {
    for (j = 1; j <= n; ++j)
      printf("%d ", map[i][j]);
    putchar('\n');
  }
  putchar('\n');
}

int main()
{
  int cnt = 0;
  int i, j;
  while (scanf("%d", &n) == 1 && n > 0)
  {
    ++cnt;
    init();
    while (scanf("%d %d", &i, &j) == 2 && i > 0)
    {
      map[i][j] = 1;
      map[j][i] = 1;
    }
    if (n > 1)
      computed(0);
    printf("Set %d: Minimum links to open is %d\n", cnt, sum);
  }
  return 0;
}