哈密顿回路、链路、竞赛图-CFANZ编程社区

一，哈密顿回路、哈密顿链路

二，Dirac定理

三，算法

力扣 996. 正方形数组的数目

力扣 980. 不同路径 III

四，竞赛图

五，相关puzzle

1，数字满格

2，马的哈密顿回路、链路

一，哈密顿回路、哈密顿链路

图的哈密顿回路是指包含图的所有节点的回路。

图的哈密顿链路是指包含图的所有节点的链路。

二，Dirac定理

如果G是一个n（n≥3）个点的无向简单图，所有节点的度数都 ≥ n/2.0，则G中存在哈密顿回路。

证明过程：

（1）G是连通图

（2）设最长路径是L，用抽屉原理可以证明L是个环

（3）如果有节点不在环中，根据连通性可以加入一个点把环变成一条更长的路径。所以所有节点都在这个环中。

三，求解哈密顿链路

哈密顿问题其实和TSP问题差不多，是NP问题，没有特别好的算法。

回溯法：

class Hamilton
{
public:
  stack<int> hami;//哈密顿链路
  Hamilton(int n, map<int, vector<int>>& m, int type)//type=0是无向图 1是有向图
  {
    this->n = n;
    this->m = m;
    this->type = type;
    for (int i = 0; i < n; i++)dfs(i);
  }
private:
  bool dfs(int k)
  {
    s.push(k);
    if (s.size() == n) {
      hami = s;
      return true;
    }
    for (auto nk : m[k]) {
      if (visit[k])continue;
      visit[k] = 1;
      if (dfs(nk))return true;
      visit[k] = 0;
    }
    s.pop();
    return false;
  }
  int n;
  int type;
  map<int, vector<int>> m;//邻接表
  map<int, int>visit;
  stack<int>s;
};

力扣 996. 正方形数组的数目

给定一个非负整数数组 A，如果该数组每对相邻元素之和是一个完全平方数，则称这一数组为正方形数组。

返回 A 的正方形排列的数目。两个排列 A1 和 A2 不同的充要条件是存在某个索引 i，使得 A1[i] != A2[i]。

示例 1：

输入：[1,17,8] 输出：2 解释： [1,8,17] 和 [17,8,1] 都是有效的排列。

示例 2：

输入：[2,2,2] 输出：1

提示：

1 <= A.length <= 12
0 <= A[i] <= 1e9

vector<int> gnums;
class Hamilton
{
public:
  map<long long, int>ans;
  Hamilton(int n, map<int, vector<int>>& m, int type)//type=0是无向图 1是有向图
  {
    this->n = n;
    this->m = m;
    this->type = type;
    for (int i = 0; i < n; i++)dfs(i,1);
  }
private:
  bool dfs(int k,int deep)
  {
    if (visit[k])return false;
    long long h2 = h;
    hash(k);
    if (hashVisit[h])
      goto RET;
    hashVisit[h] = 1;
    if (deep == n) {
      ans[h] = 1;
      h = h2;
      return true;
    }
    visit[k] = 1;
    for (auto nk : m[k]) {
      dfs(nk,deep+1);
    }
    RET:
    visit[k] = 0;
    h = h2;
    return false;
  }
  void hash(int k)
  {
    h = ((h * (gnums[k]+123) + 666) * 789)%1000000007;
  }
  int n;
  int type;
  map<int, vector<int>> m;//邻接表
  map<int, int>visit;
  map<long long, int>hashVisit;
  long long h = 1234567;
};

class Solution {
public:
  int numSquarefulPerms(vector<int>& nums) {
    int n = nums.size();
    map<int, vector<int>>m;
    for (int i = 0; i < n; i++)for (int j = i + 1; j < n; j++) {
      if (isSquare(nums[i] + nums[j]))m[i].push_back(j), m[j].push_back(i);
    }
    gnums = nums;
    return Hamilton(n, m, 0).ans.size();
  }
  bool isSquare(int n) {
    int x = sqrt(n);
    return x * x == n;
  }
};

力扣 980. 不同路径 III

在二维网格 grid 上，有 4 种类型的方格：

1 表示起始方格。且只有一个起始方格。
2 表示结束方格，且只有一个结束方格。
0 表示我们可以走过的空方格。
-1 表示我们无法跨越的障碍。

返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目。

每一个无障碍方格都要通过一次，但是一条路径中不能重复通过同一个方格。

示例 1：

输入：[[1,0,0,0],[0,0,0,0],[0,0,2,-1]] 输出：2 解释：我们有以下两条路径： 1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2) 2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)

示例 2：

输入：[[1,0,0,0],[0,0,0,0],[0,0,0,2]] 输出：4 解释：我们有以下四条路径： 1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2),(2,3) 2. (0,0),(0,1),(1,1),(1,0),(2,0),(2,1),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3) 3. (0,0),(1,0),(2,0),(2,1),(2,2),(1,2),(1,1),(0,1),(0,2),(0,3),(1,3),(2,3) 4. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2),(2,3)

示例 3：

输入：[[0,1],[2,0]] 输出：0 解释： 没有一条路能完全穿过每一个空的方格一次。请注意，起始和结束方格可以位于网格中的任意位置。

提示：

1 <= grid.length * grid[0].length <= 20

class Hamilton
{
public:
  map<long long, int>ans;
  Hamilton(int n, map<int, vector<int>>& m, int type,int start,int e)//type=0是无向图 1是有向图
  {
    this->n = n;
    this->m = m;
    this->type = type;
    this->e = e;
    dfs(start,1);
  }
private:
  bool dfs(int k,int deep)
  {
    if (visit[k])return false;
    long long h2 = h;
    hash(k);
    if (hashVisit[h])
      goto RET;
    hashVisit[h] = 1;
    if (deep == n) {
      ans[h] = 1;
      h = h2;
      return true;
    }
    visit[k] = 1;
    for (auto nk : m[k]) {
      if (deep < n - 1 && nk == e)continue;
      dfs(nk,deep+1);
    }
    RET:
    visit[k] = 0;
    h = h2;
    return false;
  }
  void hash(int k)
  {
    h = ((h * (k+123) + 666) * 789)%1000000007;
  }
  int n;
  int type;
  map<int, vector<int>> m;//邻接表
  map<int, int>visit;
  map<long long, int>hashVisit;
  long long h = 1234567;
  int e;
};


class Solution {
public:
  int uniquePathsIII(vector<vector<int>>& grid) {
    row=grid.size(),col = grid[0].size();
    int n = row*col;
    map<int, vector<int>>m;
    int s, e;
    for (int i = 0; i < row; i++)for (int j = 0; j < col; j++) {
      if (grid[i][j] == -1) {
        n--;
        continue;
      }
      if (grid[i][j] == 1)s = id(i, j);
      if (grid[i][j] == 2)e = id(i, j);
      vector<int> v = getNeighbor4(id(i, j));
      for (int k : v)if(grid[k/col][k%col]!=-1)m[k].push_back(id(i, j));
    }
    return Hamilton(n, m, 0,s,e).ans.size();
  }
  int id(int x, int y)
  {
    return x * col + y;
  }
  vector<int> getNeighbor4(int k)
  {
    vector<int>ans;
    if (k >= col)ans.push_back(k - col);
    if (k < (row - 1) * col)ans.push_back(k + col);
    if (k % col)ans.push_back(k - 1);
    if (k % col < col - 1)ans.push_back(k + 1);
    return ans;
  }
  int row,col;
};