将N减少到1所需的最少操作数

给定一个整数元素“ N”，任务是找到使“ N”等于1所需执行的最小操作数。
允许执行的操作是：

1. 将N减1。
2. N递增1。
3. 如果N是3的倍数，则可以将N除以3。

例子：

Input: N = 4 
Output: 2 
4 – 1 = 3 
3 / 3 = 1 
The minimum number of operations required is 2.

Input: N = 8 
Output: 3 
8 + 1 = 9 
9 / 3 = 3 
3 / 3 = 1 
The minimum number of operations required is 3. 

方法：

• 如果数字是3的倍数，则将其除以3。
• 如果模3的数字为1，则将其减1。
• 如果模3的数字为2，则将其加1。
• 当数字等于2时会有一个例外，在这种情况下，数字应减1。
• 重复上述步骤，直到数字大于1，并打印最后执行的操作计数。

下面是上述方法的实现：

C++

// C++ implementation of above approach
#include
using namespace std;
 
// Function that returns the minimum
// number of operations to be performed
// to reduce the number to 1
int count_minimum_operations(long long n)
{
 
    // To stores the total number of
    // operations to be performed
    int count = 0;
    while (n > 1) {
 
        // if n is divisible by 3
        // then reduce it to n / 3
        if (n % 3 == 0)
            n /= 3;
 
        // if n modulo 3 is 1
        // decrement it by 1
        else if (n % 3 == 1)
            n--;
        else {
            if (n == 2)
                n--;
             
            // if n modulo 3 is 2
            // then increment it by 1
            else
                n++;
        }
 
        // update the counter
        count++;
    }
    return count;
}
 
// Driver code
int main()
{
 
    long long n = 4;
    long long ans = count_minimum_operations(n);
    cout<

---

Java

// Java implementation of above approach
 
class GFG {
 
    // Function that returns the minimum
    // number of operations to be performed
    // to reduce the number to 1
    static int count_minimum_operations(long n)
    {
 
        // To stores the total number of
        // operations to be performed
        int count = 0;
        while (n > 1) {
 
            // if n is divisible by 3
            // then reduce it to n / 3
            if (n % 3 == 0)
                n /= 3;
 
            // if n modulo 3 is 1
            // decrement it by 1
            else if (n % 3 == 1)
                n--;
            else {
                if (n == 2)
                    n--;
 
                // if n modulo 3 is 2
                // then increment it by 1
                else
                    n++;
            }
 
            // update the counter
            count++;
        }
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
 
        long n = 4;
        long ans = count_minimum_operations(n);
        System.out.println(ans);
    }
}

Python3

# Python3 implementation of above approach
 
# Function that returns the minimum
# number of operations to be performed
# to reduce the number to 1
def count_minimum_operations(n):
 
    # To stores the total number of
    # operations to be performed
    count = 0
    while (n > 1) :
 
        # if n is divisible by 3
        # then reduce it to n / 3
        if (n % 3 == 0):
            n //= 3
 
        # if n modulo 3 is 1
        # decrement it by 1
        elif (n % 3 == 1):
            n -= 1
        else :
            if (n == 2):
                n -= 1
             
            # if n modulo 3 is 2
            # then increment it by 1
            else:
                n += 1
         
        # update the counter
        count += 1
     
    return count
 
# Driver code
if __name__ =="__main__":
    n = 4
    ans = count_minimum_operations(n)
    print (ans)
 
# This code is contributed
# by ChitraNayal

C#

// C# implementation of above approach
using System;
 
public class GFG{
     
        // Function that returns the minimum
    // number of operations to be performed
    // to reduce the number to 1
    static int count_minimum_operations(long n)
    {
 
        // To stores the total number of
        // operations to be performed
        int count = 0;
        while (n > 1) {
 
            // if n is divisible by 3
            // then reduce it to n / 3
            if (n % 3 == 0)
                n /= 3;
 
            // if n modulo 3 is 1
            // decrement it by 1
            else if (n % 3 == 1)
                n--;
            else {
                if (n == 2)
                    n--;
 
                // if n modulo 3 is 2
                // then increment it by 1
                else
                    n++;
            }
 
            // update the counter
            count++;
        }
        return count;
    }
 
    // Driver code
    static public void Main (){
     
        long n = 4;
        long ans = count_minimum_operations(n);
        Console.WriteLine(ans);
    }
}

PHP

 1)
    {
 
        // if n is divisible by 3
        // then reduce it to n / 3
        if ($n % 3 == 0)
            $n /= 3;
 
        // if n modulo 3 is 1
        // decrement it by 1
        else if ($n % 3 == 1)
            $n--;
        else
        {
            if ($n == 2)
                $n--;
             
            // if n modulo 3 is 2
            // then increment it by 1
            else
                $n++;
        }
 
        // update the counter
        $count++;
    }
    return $count;
}
 
// Driver code
$n = 4;
 
$ans = count_minimum_operations($n);
echo $ans, "\n";
 
// This code is contributed by akt_mit
?>

Javascript

 
    // Javascript implementation of above approach
     
    // Function that returns the minimum
    // number of operations to be performed
    // to reduce the number to 1
    function count_minimum_operations(n)
    {
 
        // To stores the total number of
        // operations to be performed
        let count = 0;
        while (n > 1) {
 
            // if n is divisible by 3
            // then reduce it to n / 3
            if (n % 3 == 0)
                n /= 3;
 
            // if n modulo 3 is 1
            // decrement it by 1
            else if (n % 3 == 1)
                n--;
            else {
                if (n == 2)
                    n--;
 
                // if n modulo 3 is 2
                // then increment it by 1
                else
                    n++;
            }
 
            // update the counter
            count++;
        }
        return count;
    }
     
    let n = 4;
    let ans = count_minimum_operations(n);
    document.write(ans);
     

输出

2

递归方法：递归方法类似于上面使用的方法。

下面是实现：

C++

// C++ implementation of above approach
#include 
using namespace std;
 
// Function that returns the minimum
// number of operations to be performed
// to reduce the number to 1
int count_minimum_operations(long long n)
{
 
    // Base cases
    if (n == 2) {
        return 1;
    }
    else if (n == 1) {
        return 0;
    }
    if (n % 3 == 0) {
        return 1 + count_minimum_operations(n / 3);
    }
    else if (n % 3 == 1) {
        return 1 + count_minimum_operations(n - 1);
    }
    else {
        return 1 + count_minimum_operations(n + 1);
    }
}
 
// Driver code
int main()
{
 
    long long n = 4;
    long long ans = count_minimum_operations(n);
    cout << ans << endl;
    return 0;
}
 
// This code is contributed by koulick_sadhu

Java

// Java implementation of above approach
import java.util.*;
 
class GFG{
     
// Function that returns the minimum
// number of operations to be performed
// to reduce the number to 1
public static int count_minimum_operations(int n)
{
     
    // Base cases
    if (n == 2)
    {
        return 1;
    }
    else if (n == 1)
    {
        return 0;
    }
    if (n % 3 == 0)
    {
        return 1 + count_minimum_operations(n / 3);
    }
    else if (n % 3 == 1)
    {
        return 1 + count_minimum_operations(n - 1);
    }
    else
    {
        return 1 + count_minimum_operations(n + 1);
    }
}
 
// Driver code
public static void main(String []args)
{
    int n = 4;
    int ans = count_minimum_operations(n);
     
    System.out.println(ans);
}
}
 
// This code is contributed by avanitrachhadiya2155

Python3

# Python3 implementation of above approach
 
# Function that returns the minimum
# number of operations to be performed
# to reduce the number to 1
def count_minimum_operations(n):
     
    # Base cases
    if (n == 2):
        return 1
    elif (n == 1):
        return 0
    if (n % 3 == 0):
        return 1 + count_minimum_operations(n / 3)
    elif (n % 3 == 1):
        return 1 + count_minimum_operations(n - 1)
    else:
        return 1 + count_minimum_operations(n + 1)
 
# Driver Code
n = 4
ans = count_minimum_operations(n)
 
print(ans)
 
# This code is contributed by divyesh072019

C＃

// C# implementation of above approach
using System;
class GFG {
     
    // Function that returns the minimum
    // number of operations to be performed
    // to reduce the number to 1
    static int count_minimum_operations(int n)
    {
      
        // Base cases
        if (n == 2) {
            return 1;
        }
        else if (n == 1) {
            return 0;
        }
        if (n % 3 == 0) {
            return 1 + count_minimum_operations(n / 3);
        }
        else if (n % 3 == 1) {
            return 1 + count_minimum_operations(n - 1);
        }
        else {
            return 1 + count_minimum_operations(n + 1);
        }
    }
   
  // Driver code
  static void Main() {
    int n = 4;
    int ans = count_minimum_operations(n);
    Console.WriteLine(ans);
  }
}
 
// This code is contributed by divyeshrabadiya07

Java脚本

    // Javascript implementation of above approach
     
    // Function that returns the minimum
    // number of operations to be performed
    // to reduce the number to 1
    function count_minimum_operations(n)
    {
 
        // Base cases
        if (n == 2) {
            return 1;
        }
        else if (n == 1) {
            return 0;
        }
        if (n % 3 == 0) {
            return 1 + count_minimum_operations(n / 3);
        }
        else if (n % 3 == 1) {
            return 1 + count_minimum_operations(n - 1);
        }
        else {
            return 1 + count_minimum_operations(n + 1);
        }
    }
     
    let n = 4;
    let ans = count_minimum_operations(n);
    document.write(ans);
     
    // This code is contributed by suresh07.

输出：

2