下一个较高的回文数，使用相同的数字集

给定回文数num ，其中n个数字。问题是要找到使用同一组数字作为NUM最小的回文数大于NUM。如果无法形成此类编号，请打印“不可能”。
该数字可能非常大，并且可能适合甚至可能不适合int long int。
例子：

Input : 4697557964
Output :  4756996574

Input : 543212345
Output : Not Possible

方法：以下是步骤：

1. 如果数字位数n <= 3，则打印“不可能”并返回。
2. 计算中= n / 2 – 1。
3. 从索引中的数字开始遍历直到第一个数字，并在遍历时找到最右边的数字的索引i ，该索引的i小于右边的数字。
4. 现在在索引范围i + 1到mid中搜索大于位数num [i]的最小位数。让该数字的索引最小。
5. 如果找不到这样的最小数字，则打印“不可能”。
6. 否则，将索引i和最小的数字交换，也将索引ni-1和n-smallest-1的数字交换。进行此步骤是为了保持回文性质为num 。
7. 现在将索引范围i + 1到mid的数字反转。同样，如果n为偶数，则将索引范围mid + 1的数字反转为ni-2，否则，如果n为奇数，则将索引范围中值+2的数字反转为ni-2 。进行此步骤是为了保持回文性质为num 。
8. 打印最终修改的数字num 。

C++

// C++ implementation to find next higher
// palindromic number using the same set
// of digits
#include 
using namespace std;
 
// function to reverse the digits in the
// range i to j in 'num'
void reverse(char num[], int i, int j)
{
    while (i < j) {
        swap(num[i], num[j]);
        i++;
        j--;
    }
}
 
// function to find next higher palindromic
// number using the same set of digits
void nextPalin(char num[], int n)
{
    // if length of number is less than '3'
    // then no higher palindromic number
    // can be formed
    if (n <= 3) {
        cout << "Not Possible";
        return;
    }
 
    // find the index of last digit
    // in the 1st half of 'num'
    int mid = n / 2 - 1;
    int i, j;
 
    // Start from the (mid-1)th digit and
    // find the first digit that is
    // smaller than the digit next to it.
    for (i = mid - 1; i >= 0; i--)
        if (num[i] < num[i + 1])
            break;
 
    // If no such digit is found, then all
    // digits are in descending order which
    // means there cannot be a greater
    // palindromic number with same set of
    // digits
    if (i < 0) {
        cout << "Not Possible";
        return;
    }
 
    // Find the smallest digit on right
    // side of ith digit which is greater
    // than num[i] up to index 'mid'
    int smallest = i + 1;
    for (j = i + 2; j <= mid; j++)
        if (num[j] > num[i] &&
            num[j] <= num[smallest])
            smallest = j;
 
    // swap num[i] with num[smallest]
    swap(num[i], num[smallest]);
 
    // as the number is a palindrome, the same
    // swap of digits should be performed in
    // the 2nd half of 'num'
    swap(num[n - i - 1], num[n - smallest - 1]);
 
    // reverse digits in the range (i+1) to mid
    reverse(num, i + 1, mid);
 
    // if n is even, then reverse digits in the
    // range mid+1 to n-i-2
    if (n % 2 == 0)
        reverse(num, mid + 1, n - i - 2);
 
    // else if n is odd, then reverse digits
    // in the range mid+2 to n-i-2
    else
        reverse(num, mid + 2, n - i - 2);
 
    // required next higher palindromic number
    cout << "Next Palindrome: "
         << num;
}
 
// Driver program to test above
int main()
{
    char num[] = "4697557964";
    int n = strlen(num);
    nextPalin(num, n);
    return 0;
}

Java

// Java implementation to find next higher
// palindromic number using the same set
// of digits
import java.util.*;
 
class NextHigherPalindrome
{
    // function to reverse the digits in the
    // range i to j in 'num'
    public static void reverse(char num[], int i,
                                          int j)
    {
        while (i < j) {
            char temp = num[i];
            num[i] = num[j];
            num[j] = temp;
            i++;
            j--;
        }
    }
     
    // function to find next higher palindromic
    // number using the same set of digits
    public static void nextPalin(char num[], int n)
    {
        // if length of number is less than '3'
        // then no higher palindromic number
        // can be formed
        if (n <= 3) {
            System.out.println("Not Possible");
            return;
        }
        char temp;
         
        // find the index of last digit
        // in the 1st half of 'num'
        int mid = n / 2 - 1;
        int i, j;
     
        // Start from the (mid-1)th digit and
        // find the first digit that is
        // smaller than the digit next to it.
        for (i = mid - 1; i >= 0; i--)
            if (num[i] < num[i + 1])
                break;
     
        // If no such digit is found, then all
        // digits are in descending order which
        // means there cannot be a greater
        // palindromic number with same set of
        // digits
        if (i < 0) {
            System.out.println("Not Possible");
            return;
        }
     
        // Find the smallest digit on right
        // side of ith digit which is greater
        // than num[i] up to index 'mid'
        int smallest = i + 1;
        for (j = i + 2; j <= mid; j++)
            if (num[j] > num[i] &&
                num[j] <= num[smallest])
                smallest = j;
     
        // swap num[i] with num[smallest]
        temp = num[i];
        num[i] = num[smallest];
        num[smallest] = temp;
         
        // as the number is a palindrome,
        // the same swap of digits should
        // be performed in the 2nd half of
        // 'num'
        temp = num[n - i - 1];
        num[n - i - 1] = num[n - smallest - 1];
        num[n - smallest - 1] = temp;
         
        // reverse digits in the range (i+1)
        // to mid
        reverse(num, i + 1, mid);
     
        // if n is even, then reverse
        // digits in the range mid+1 to
        // n-i-2
        if (n % 2 == 0)
            reverse(num, mid + 1, n - i - 2);
     
        // else if n is odd, then reverse
        // digits in the range mid+2 to n-i-2
        else
            reverse(num, mid + 2, n - i - 2);
     
        // required next higher palindromic
        // number
        String result=String.valueOf(num);
        System.out.println("Next Palindrome: "+
                                   result);
    }
     
    // Driver Code
    public static void main(String args[])
    {
        String str="4697557964";
        char num[]=str.toCharArray();
        int n=str.length();
        nextPalin(num,n);
    }
}
 
// This code is contributed by Danish Kaleem

Python

# Python implementation to find next higher
# palindromic number using the same set
# of digits
 
# function to reverse the digits in the
# range i to j in 'num'
def reverse(num, i, j) :
     
    while (i < j) :
        temp = num[i]
        num[i] = num[j]
        num[j] = temp
        i = i + 1
        j = j - 1
         
     
# function to find next higher palindromic
# number using the same set of digits
def nextPalin(num, n) :
     
    # if length of number is less than '3'
    # then no higher palindromic number
    # can be formed
    if (n <= 3) :
        print "Not Possible"
        return
     
    # find the index of last digit
    # in the 1st half of 'num'
    mid = n / 2 - 1
     
    # Start from the (mid-1)th digit and
    # find the first digit that is
    # smaller than the digit next to it.
    i = mid - 1
    while i >= 0 :
        if (num[i] < num[i + 1]) :
            break
        i = i - 1
     
    # If no such digit is found, then all
    # digits are in descending order which
    # means there cannot be a greater
    # palindromic number with same set of
    # digits
    if (i < 0) :
        print "Not Possible"
        return
     
    # Find the smallest digit on right
    # side of ith digit which is greater
    # than num[i] up to index 'mid'
    smallest = i + 1
    j = i + 2
    while j <= mid :
        if (num[j] > num[i] and num[j] <
                        num[smallest]) :
            smallest = j
        j = j + 1
     
    # swap num[i] with num[smallest]
    temp = num[i]
    num[i] = num[smallest]
    num[smallest] = temp
     
    # as the number is a palindrome,
    # the same swap of digits should
    # be performed in the 2nd half of
    # 'num'
    temp = num[n - i - 1]
    num[n - i - 1] = num[n - smallest - 1]
    num[n - smallest - 1] = temp
     
    # reverse digits in the range (i+1)
    # to mid
    reverse(num, i + 1, mid)
     
    # if n is even, then reverse
    # digits in the range mid+1 to
    # n-i-2
    if (n % 2 == 0) :
        reverse(num, mid + 1, n - i - 2)
         
    # else if n is odd, then reverse
    # digits in the range mid+2 to n-i-2
    else :
        reverse(num, mid + 2, n - i - 2)
         
         
    # required next higher palindromic
    # number
    result = ''.join(num)
     
    print "Next Palindrome: ",result
     
# Driver Code
st = "4697557964"
num = list(st)
n = len(st)
nextPalin(num, n)
 
# This code is contributed by Nikita Tiwari

C#

// C# implementation to find
// next higher palindromic
// number using the same set
// of digits
using System;
 
class GFG
{
    // function to reverse
    // the digits in the
    // range i to j in 'num'
    public static void reverse(char[] num,
                               int i, int j)
    {
        while (i < j)
        {
            char temp = num[i];
            num[i] = num[j];
            num[j] = temp;
            i++;
            j--;
        }
    }
     
    // function to find next
    // higher palindromic number
    // using the same set of digits
    public static void nextPalin(char[] num,
                                 int n)
    {
        // if length of number is
        // less than '3' then no
        // higher palindromic number
        // can be formed
        if (n <= 3)
        {
            Console.WriteLine("Not Possible");
            return;
        }
        char temp;
         
        // find the index of last
        // digit in the 1st half
        // of 'num'
        int mid = n / 2 - 1;
        int i, j;
     
        // Start from the (mid-1)th
        // digit and find the
        // first digit that is
        // smaller than the digit
        // next to it.
        for (i = mid - 1; i >= 0; i--)
            if (num[i] < num[i + 1])
                break;
     
        // If no such digit is found,
        // then all digits are in
        // descending order which
        // means there cannot be a
        // greater palindromic number
        // with same set of digits
        if (i < 0)
        {
            Console.WriteLine("Not Possible");
            return;
        }
     
        // Find the smallest digit on
        // right side of ith digit 
        // which is greater than num[i]
        // up to index 'mid'
        int smallest = i + 1;
        for (j = i + 2; j <= mid; j++)
            if (num[j] > num[i] &&
                num[j] < num[smallest])
                smallest = j;
     
        // swap num[i] with
        // num[smallest]
        temp = num[i];
        num[i] = num[smallest];
        num[smallest] = temp;
         
        // as the number is a palindrome,
        // the same swap of digits should
        // be performed in the 2nd half of
        // 'num'
        temp = num[n - i - 1];
        num[n - i - 1] = num[n - smallest - 1];
        num[n - smallest - 1] = temp;
         
        // reverse digits in the 
        // range (i+1) to mid
        reverse(num, i + 1, mid);
     
        // if n is even, then
        // reverse digits in the
        // range mid+1 to n-i-2
        if (n % 2 == 0)
            reverse(num, mid + 1,
                    n - i - 2);
     
        // else if n is odd, then
        // reverse digits in the
        // range mid+2 to n-i-2
        else
            reverse(num, mid + 2,
                    n - i - 2);
     
        // required next higher
        // palindromic number
        String result = new String(num);
        Console.WriteLine("Next Palindrome: "+
                                      result);
    }
     
    // Driver Code
    public static void Main()
    {
        String str = "4697557964";
        char[] num = str.ToCharArray();
        int n = str.Length;
        nextPalin(num, n);
    }
}
 
// This code is contributed by mits

PHP

= 0; $i--)
        if ($num[$i] < $num[$i + 1])
            break;
 
    // If no such digit is found,
    // then all digits are in
    // descending order which means
    // there cannot be a greater
    // palindromic number with same
    // set of digits
    if ($i < 0)
    {
        echo "Not Possible";
        return;
    }
 
    // Find the smallest digit on right
    // side of ith digit which is greater
    // than num[i] up to index 'mid'
    $smallest = $i + 1;
    $j = 0;
    for ($j = $i + 2; $j <= $mid; $j++)
        if ($num[$j] > $num[$i] &&
            $num[$j] < $num[$smallest])
            $smallest = $j;
 
    // swap num[i] with num[smallest]
    $t = $num[$i];
    $num[$i] = $num[$smallest];
    $num[$smallest] = $t;
     
    // as the number is a palindrome,
    // the same swap of digits should
    // be performed in the 2nd half of 'num'
    $t = $num[$n - $i - 1];
    $num[$n - $i - 1] = $num[$n - $smallest - 1];
    $num[$n - $smallest - 1] = $t;
 
    // reverse digits in the
    // range (i+1) to mid
    reverse($num, $i + 1, $mid);
 
    // if n is even, then
    // reverse digits in the
    // range mid+1 to n-i-2
    if ($n % 2 == 0)
        reverse($num, $mid + 1, $n - $i - 2);
 
    // else if n is odd, then reverse
    // digits in the range mid+2
    // to n-i-2
    else
        reverse($num, $mid + 2, $n - $i - 2);
 
    // required next higher
    // palindromic number
    echo "Next Palindrome: " . $num;
}
 
// Driver Code
$num = "4697557964";
$n = strlen($num);
nextPalin($num, $n);
 
// This code is contributed by mits
?>

输出：

Next Palindrome: 4756996574