E verifique a coleção de explicações detalhadas - a lenda do cavaleiro

   E a coleção de cheques é um truque que aprendi com os mestres durante as férias de verão, e acho que é realmente um design sofisticado. Um tipo de problema que eu não conseguia resolver antes, pode ser resolvido de forma simples e eficiente. Sinto muito por não compartilhar isso. (Parte: eu confio nisso, é da minha conta? Conheço você?)

Vejamos um exemplo, o projeto Hang Dian 1232 Smooth

Projeto Hang Dian 1232 Smooth

  Primeiro, mostre várias cidades no mapa, essas cidades podem ser consideradas pontos e, a seguir, diga quais pares de cidades estão diretamente conectados por estradas.
A última coisa a ser resolvida é o problema de conectividade de todo o quadro. Por exemplo, dê a você dois pontos à vontade, deixe você julgar se eles estão conectados, ou pergunte quantos ramos conectados em toda a imagem, ou seja, ela está dividida em vários blocos independentes.
Assim como o problema da engenharia desobstruída, quantas estradas precisam ser reparadas, a essência é ter vários ramais conectados.
Se for uma ramificação conectada, significa que os pontos de todo o mapa estão conectados e não há necessidade de reparar a estrada; se for uma ramificação conectada, você só precisa construir outra estrada e escolher um ponto de cada uma das duas ramificações. Conecte-os e todos os pontos serão conectados;
se houver 3 ramais conectados, você só precisa
  construir mais duas estradas ... Use os seguintes dados de entrada de dados para ilustrar

4 2 1 3 4 3

  A primeira linha informa que existem 4 pontos e 2 estradas. As próximas duas linhas indicam que existe uma estrada entre 1 e 3 e que existe uma estrada entre 4 e 3. Em seguida, toda a imagem é dividida em duas partes, 1-3-4 e 2. Basta adicionar outro caminho, conectar 2 a qualquer outro ponto e o projeto harmonioso será realizado, então o resultado de saída deste grupo de dados é 1.
Ok, vamos programar para realizar esta função. Existem centenas de cidades, quantas estradas existem e pode haver curvas. Como isso pode ser bom?

  Não sabia antes, depois de usar e conferir a coleção, ei, o efeito é muito bom! Nossa família inteira usa!

  O conjunto de pesquisa de união consiste em uma matriz de inteiros e duas funções. O array pre [] registra qual é o ponto principal de cada ponto. A função find é localizar e juntar é fundir.

int pre[1000 ];

int find(int x){
    
     //查找根节点

int r=x; while (pre[r ]!=r) r=pre[r ]; //路径压缩

int i=x; int j; while(i!=r) {
    
     j=pre[i ]; pre[i ]=r; i=j; } //返回根节点

return r;

void join(int x,int y) {
    
     //判断x y是否连通

//如果已经连通，就不用管了 //如果不连通，就把它们所在的连通分支合并起,

int fx=find(x),fy=find(y);

if(fx!=fy) pre[fx ]=fy; }

Comece a explicar e coletar

   Para explicar o princípio de colecionar e colecionar, darei um exemplo mais amoroso. Existem milhares de heróis de todos os tipos espalhados nos rios e lagos. Eles não têm profissões adequadas, andam por aí com suas espadas nas costas o dia todo e, inevitavelmente, terão que lutar se encontrarem pessoas que não são iguais a eles. Mas os heróis têm a vantagem de falar lealdade e nunca derrotar seus amigos. E acreditam em "amigo de amigo é meu amigo", desde que possam estar ligados por uma amizade, não importa quantas voltas tomem, pensam que são seus. Desta forma, comunidades foram se formando uma a uma nos rios e lagos, que estão conectadas pela amizade entre os dois. Pessoas que não são da mesma comunidade não podem ser conectadas por meio de amizades, então podem ser espancadas até a morte com confiança. Mas como duas pessoas que não se conheciam podem saber se pertencem a um círculo de amigos?

Podemos nomear uma pessoa de maior prestígio em cada círculo de amigos como representante do círculo. Desta forma, cada círculo pode ser nomeado como "Zidane Friends Team" e "Ronaldo Friends Team" ... dois Contanto que as pessoas verifiquem se seu capitão é a mesma pessoa, elas podem determinar a relação entre inimigo e amigo.
  Mas ainda há um problema. Os heróis só sabem quem são seus amigos diretos. Muitas pessoas não conhecem o capitão. Para julgar quem é seu capitão, eles só podem perguntar à toa por meio da amizade de amigos: "Você Você é o capitão? Você é o capitão? ”Desse modo, o capitão perderia a credibilidade e sua eficiência seria muito baixa, e ele poderia cair em um loop infinito.
  Então o capitão ordenou que se reagrupassem. Todos na equipe implementam um sistema hierárquico para formar uma estrutura em árvore. Meu líder de equipe é o nó raiz. Abaixo estão os jogadores de segundo e terceiro níveis. Todo mundo só precisa se lembrar de quem são seus superiores.
  Ao encontrar juízes de inimigos e amigos, desde que você pergunte um por um até o nível mais alto, você pode determinar quem é o capitão em um curto espaço de tempo. Já que só nos importamos se duas pessoas estão conectadas, como estão conectadas, qual é a estrutura interna de cada círculo e até mesmo quem é o capitão, não importa. Assim, podemos deixar o capitão se reagrupar à vontade, desde que não cometamos erros na relação entre inimigo e amigo.
  Assim, a arte marcial surgiu.

   下面我们来看并查集的实现。 int pre[1000]; 这个数组，记录了每个大侠的上级是谁。大侠们从1或者0开始编号（依据题意而定），pre[15]=3就表示15号大侠的上级是3号大侠。
  如果一个人的上级就是他自己，那说明他就是掌门人了，查找到此为止。也有孤家寡人自成一派的，比如欧阳锋，那么他的上级就是他自己。
  每个人都只认自己的上级。比如胡青牛同学只知道自己的上级是杨左使。张无忌是谁？不认识！要想知道自己的掌门是谁，只能一级级查上去。
  find这个函数就是找掌门用的，意义再清楚不过了（路径压缩算法先不论，后面再说）。

int find(int x) {
    
     //查找根节点

int r=x; while (pre[r ]!=r)//如果我的上级不是掌门

r=pre[r ];//我就接着找他的上级，直到找到掌门为止。

//返回根节点

return r;//掌门驾到~~~

}

join函数

   再来看看join函数，就是在两个点之间连一条线，这样一来，原先它们所在的两个板块的所有点就都可以互通了。这在图上很好办，画条线就行了。
  但我们现在是用并查集来描述武林中的状况的，一共只有一个pre[]数组，该如何实现呢？ 还是举江湖的例子，假设现在武林中的形势如图所示。虚竹小和尚与周芷若MM是我非常喜欢的两个人物，他们的终极boss分别是玄慈方丈和灭绝师太，那明显就是两个阵营了。
  我不希望他们互相打架，就对他俩说：“你们两位拉拉勾，做好朋友吧。”他们看在我的面子上，同意了。
   这一同意可非同小可，整个少林和峨眉派的人就不能打架了。这么重大的变化，可如何实现呀，要改动多少地方？其实非常简单，我对玄慈方丈说：“大师，麻烦你把你的上级改为灭绝师太吧。
   这样一来，两派原先的所有人员的终极boss都是师太，那还打个球啊！反正我们关心的只是连通性，门派内部的结构不要紧的。”
  玄慈一听肯定火大了：“我靠，凭什么是我变成她手下呀，怎么不反过来？我抗议！”抗议无效，上天安排的，最大。反正谁加入谁效果是一样的，我就随手指定了一个。这段函数的意思很明白了吧？

void join(int x,int y)//我想让虚竹和周芷若做朋友

{
    
     int fx=find(x),fy=find(y); //虚竹的老大是玄慈，

芷若MM的老大是灭绝

if(fx!=fy)//玄慈和灭绝显然不是同一个人

pre[fx ]=fy;//方丈只好委委屈屈地当了师太的手下啦

}

路径压缩算法

   再来看看路径压缩算法。建立门派的过程是用join函数两个人两个人地连接起来的，谁当谁的手下完全随机。最后的树状结构会变成什么胎唇样，我也完全无法预计，一字长蛇阵也有可能。这样查找的效率就会比较低下。最理想的情况就是所有人的直接上级都是掌门，一共就两级结构，只要找一次就找到掌门了。
  哪怕不能完全做到，也最好尽量接近。这样就产生了路径压缩算法。 设想这样一个场景：两个互不相识的大侠碰面了，想知道能不能揍。 于是赶紧打电话问自己的上级：“你是不是掌门？” 上级说：“我不是呀，我的上级是谁谁谁，你问问他看看。” 一路问下去，原来两人的最终boss都是东厂曹公公。
   “哎呀呀，原来是记己人，西礼西礼，在下三营六组白面葫芦娃!” “幸会幸会，在下九营十八组仙子狗尾巴花！” 两人高高兴兴地手拉手喝酒去了。 “等等等等，两位同学请留步，还有事情没完成呢！”我叫住他俩。 “哦，对了，还要做路径压缩。”两人醒悟。 白面葫芦娃打电话给他的上级六组长：“组长啊，我查过了，其习偶们的掌门是曹公公。不如偶们一起及接拜在曹公公手下吧，省得级别太低，以后查找掌门麻环。” “唔，有道理。” 白面葫芦娃接着打电话给刚才拜访过的三营长……仙子狗尾巴花也做了同样的事情。
  这样，查询中所有涉及到的人物都聚集在曹公公的直接领导下。每次查询都做了优化处理，所以整个门派树的层数都会维持在比较低的水平上。路径压缩的代码，看得懂很好，看不懂也没关系，直接抄上用就行了。总之它所实现的功能就是这么个意思。

回到开头提出的问题，我的代码如下：

#include int pre[1000 ];

int find(int x) {
    
    

int r=x;

while (pre[r ]!=r)

r=pre[r ];

int i=x; int j;

while(i!=r)

{
    
    

j=pre[i ]; pre[i ]=r; i=j;

}

return r;

}

int main()

{
    
     int n,m,p1,p2,i,total,f1,f2;

while(scanf("%d",&n) && n)//读入n，如果n为0，结束 { //刚开始的时候，有n个城镇，一条路都没有 //那么要修n-1条路才能把它们连起来

total=n-1;

//每个点互相独立，自成一个集合，从1编号到n //所以每个点的上级都是自己

for(i=1;i<=n;i++) {
    
     pre[i ]=i; } //共有m条路

scanf("%d",&m); while(m--) {
    
     //下面这段代码，其实就是join函数，只是稍作改动以适应题目要求

//每读入一条路，看它的端点p1，p2是否已经在一个连通分支里了

scanf("%d %d",&p1,&p2);

f1=find(p1); f2=find(p2);

//如果是不连通的，那么把这两个分支连起来

//分支的总数就减少了1，还需建的路也就减了1

if(f1!=f2) {
    
     pre[f2 ]=f1; total--;

}

//如果两点已经连通了，那么这条路只是在图上增加了一个环 //对连通性没有任何影响，无视掉

}

//最后输出还要修的路条数

printf("%d\n",total); } return 0;

}

``