📌  相关文章
📜  通过重复将除 1 和数字以外的任何数字除数加到自身上,使 M 和 N 相等的最小移动次数

📅  最后修改于: 2021-10-25 04:49:35             🧑  作者: Mango

给定两个数字NM,任务是找到将N更改为M-1(如果不可能)的最小移动次数。在一步中,将任何不等于 1 的除数和数字本身添加到当前数字上。

例子:

接近:建立一个图,其中顶点从NM号和有从边缘顶点V1V2顶点V2是否可以从V1使用从问题陈述正好一个操作来获得。为了解决这个问题,在这个图中找到从顶点N到顶点M的最短路径。这可以使用广度优先搜索算法来完成。请按照以下步骤解决问题:

  • 初始化一个布尔数组visited[]来存储一个特定的数字是否被计算在内。
  • 用值false填充 bool 数组visited[] 的所有索引,并将visited[N]的值设置为true。
  • 初始化成对队列q以存储访问的数量和完成的操作数量。
  • {N, 0}对推入对q的队列中。
  • 在一个范围内迭代,直到对q的队列不为空。
    • 将变量aux初始化为队列q的前对的第一个值,将cont初始化为队列q的前对的第二个值
    • 从对q的队列中弹出前对
    • 如果aux等于M,则返回cont的值
    • 在范围[2, aux 1/2 ] 中迭代并执行以下步骤。
      • 如果iaux的因子则执行以下步骤。
        • 如果aux+i小于等于Mvisited[i+aux]false,则将visited[aux+i]的值设置为true并将{aux+i, cont+1}对推入对q。
        • 如果aux+aux/i小于等于M并且visited[aux/i+aux]false,则将visited[aux+aux/i]的值设置为true并推送对{aux+aux/i, cont+1}进入对q的队列
  • 返回-1 ,因为不可能使N等于M。

下面是上述方法的实现。

C++
// C++ program for the above approach.
#include 
using namespace std;
 
// Function to find the minimum number
// of moves to make N and M equal.
int countOperations(int N, int M)
{
    // Array to maintain the numbers
    // included.
    bool visited[100001];
    fill(visited, visited + 100001, false);
 
    // pair of vertex, count
    queue > Q;
    Q.push(make_pair(N, 0));
    visited[N] = true;
 
    // run bfs from N
    while (!Q.empty()) {
        int aux = Q.front().first;
        int cont = Q.front().second;
        Q.pop();
 
        // if we reached goal
        if (aux == M)
            return cont;
 
        // Iterate in the range
        for (int i = 2; i * i <= aux; i++)
            // If i is a factor of aux
            if (aux % i == 0) {
                // If i is less than M-aux and
                // is not included earlier.
                if (aux + i <= M && !visited[aux + i]) {
                    Q.push(make_pair(aux + i, cont + 1));
                    visited[aux + i] = true;
                }
                // If aux/i is less than M-aux and
                // is not included earlier.
                if (aux + aux / i <= M
                    && !visited[aux + aux / i]) {
                    Q.push(
                        make_pair(aux + aux / i, cont + 1));
                    visited[aux + aux / i] = true;
                }
            }
    }
 
    // Not possible
    return -1;
}
 
// Driver Code
int main()
{
 
    int N = 4, M = 24;
 
    cout << countOperations(N, M);
 
    return 0;
}


Java
// Java program for above approach
import java.util.*;
 
class GFG{
     
static class pair
{
    T first;
    V second;
}
 
static pair make_pair(int f, int s)
{
    pair p = new pair<>();
    p.first = f; p.second = s;
    return p;
}
 
// Function to find the minimum number
// of moves to make N and M equal.
static int countOperations(int N, int M)
{
     
    // Array to maintain the numbers
    // included.
    boolean[] visited = new boolean[100001];
    Arrays.fill(visited, false);
 
    // Pair of vertex, count
    Queue> Q = new LinkedList<>();
    Q.add(make_pair(N, 0));
    visited[N] = true;
 
    // Run bfs from N
    while (!Q.isEmpty())
    {
        int aux = Q.peek().first;
        int cont = Q.peek().second;
        Q.remove();
 
        // If we reached goal
        if (aux == M)
            return cont;
 
        // Iterate in the range
        for(int i = 2; i * i <= aux; i++)
         
            // If i is a factor of aux
            if (aux % i == 0)
            {
                 
                // If i is less than M-aux and
                // is not included earlier.
                if (aux + i <= M && !visited[aux + i])
                {
                    Q.add(make_pair(aux + i, cont + 1));
                    visited[aux + i] = true;
                }
                 
                // If aux/i is less than M-aux and
                // is not included earlier.
                if (aux + aux / i <= M &&
                    !visited[aux + aux / i])
                {
                    Q.add(make_pair(aux + aux / i,
                                   cont + 1));
                    visited[aux + aux / i] = true;
                }
            }
    }
     
    // Not possible
    return -1;
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 4, M = 24;
     
    System.out.println(countOperations(N, M));
}
}
 
// This code is contributed by hritikrommie


Python3
# Python3 program for the above approach.
 
# Function to find the minimum number
# of moves to make N and M equal.
def countOperations(N, M):
  
    # Array to maintain the numbers
    # included.
    visited = [False] * (100001)
    
    # Pair of vertex, count
    Q = []
    Q.append([N, 0])
    visited[N] = True
      
    # Run bfs from N
    while (len(Q) > 0):
        aux = Q[0][0]
        cont = Q[0][1]
        Q.pop(0)
    
        # If we reached goal
        if (aux == M):
            return cont
    
        # Iterate in the range
        i = 2
         
        while i * i <= aux:
             
            # If i is a factor of aux
            if (aux % i == 0):
                 
                # If i is less than M-aux and
                # is not included earlier.
                if (aux + i <= M and not visited[aux + i]):
                    Q.append([aux + i, cont + 1])
                    visited[aux + i] = True
                 
                # If aux/i is less than M-aux and
                # is not included earlier.
                if (aux + int(aux / i) <= M and not
                    visited[aux + int(aux / i)]):
                    Q.append([aux + int(aux / i), cont + 1])
                    visited[aux + int(aux / i)] = True
                     
            i += 1
    
    # Not possible
    return -1
 
# Driver code
N, M = 4, 24
  
print(countOperations(N, M))
 
# This code is contributed by mukesh07


C#
// C# program for the above approach.
using System;
using System.Collections;
class GFG
{
     
    // Function to find the minimum number
    // of moves to make N and M equal.
    static int countOperations(int N, int M)
    {
        // Array to maintain the numbers
        // included.
        bool[] visited = new bool[100001];
      
        // pair of vertex, count
        Queue Q = new Queue();
        Q.Enqueue(new Tuple(N, 0));
        visited[N] = true;
        // run bfs from N
        while (Q.Count > 0) {
            int aux = ((Tuple)(Q.Peek())).Item1;
            int cont = ((Tuple)(Q.Peek())).Item2;
            Q.Dequeue();
      
            // if we reached goal
            if (aux == M)
                return cont;
      
            // Iterate in the range
            for (int i = 2; i * i <= aux; i++)
               
                // If i is a factor of aux
                if (aux % i == 0)
                {
                   
                    // If i is less than M-aux and
                    // is not included earlier.
                    if (aux + i <= M && !visited[aux + i]) {
                        Q.Enqueue(new Tuple(aux + i, cont + 1));
                        visited[aux + i] = true;
                    }
                   
                    // If aux/i is less than M-aux and
                    // is not included earlier.
                    if (aux + aux / i <= M
                        && !visited[aux + aux / i]) {
                        Q.Enqueue(new Tuple(aux + aux / i, cont + 1));
                        visited[aux + aux / i] = true;
                    }
                }
        }
      
        // Not possible
        return -1;
    }
     
  static void Main ()
  {
    int N = 4, M = 24;
  
    Console.WriteLine(countOperations(N, M));
  }
}
 
// This code is contributed by suresh07.


Javascript


输出
5

时间复杂度: O(N*sqrt(N))
辅助空间: O(N)

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程