计算将数字划分为递增数字序列的方法

给定一个数字字符串S ，任务是找到将字符串划分为由数字按升序组成的子字符串的方法数。

例子：

Input: S = “1345”
Output: 5
Explanation: Possible partitions are as follows: 

1. [1345]
2. [13, 45], [1, 345]
3. [1, 3, 45]
4. [1, 3, 4, 5]

Input: S = “12”
Output: 2

方法：这个问题可以通过观察每个数字之间的来解决，它要么是前一个数字的一部分，要么是一个新数字，因此可以使用递归来解决问题。请按照以下步骤解决问题：

• 初始化一个整数变量，比如count为0 ，以存储将字符串划分为递增子集的方法数。
• 用索引（存储当前位置）、字符串S （问题中的给定字符串）和字符串ans ( 作为参数声明一个函数print() 。
• 现在，需要考虑以下两种情况：
  • 如果S[index]插入到前一个数字中，则将S[index]附加到ans的末尾，并调用带有参数index + 1 、 S和ans的函数print() 。
  • 如果S[index]不是前一个数字的一部分，则在ans的末尾附加“” （空格），然后插入S[index]并调用带有参数index + 1 、 S 、 ans的函数print() 。
• 如果index = S.length() ，则检查形成的序列中的数字是否按升序排列。如果形成的序列正在增加，则将count增加1 。
• 执行上述步骤后打印计数作为答案。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include
using namespace std;
 
// Stores the number of ways
// to partition a string
int count1 = 0;
vector split(string str)
{
    vector ans;
    string word = "";
    for(auto x : str)
    {
        if (x == ' ')
        {
            ans.push_back(word);
            word = "";
        }
        else
        {
            word = word + x;
        }
    }
    ans.push_back(word);
    return ans;
}
 
// Function to check if a sequence
// is strictly increasing or not
bool check(string m)
{
     
    // If there is only one number
    if (m.length() == 1)
    {
        return true;
    }
     
    // Split the string m when there is space
    vector temp = split(m);
    int number[temp.size()];
     
    // Insert all the splits into the array
    for(int i = 0; i < temp.size(); ++i)
    {
        number[i] = stoi(temp[i]);
    }
     
    int first = number[0];
    for(int i = 1; i < temp.size(); ++i)
    {
        if (number[i] > first)
        {
            first = number[i];
        }
        else
        {
             
            // If number is not increasing
            return false;
        }
    }
     
    // If the sequence is increasing
    return true;
}
 
// Recursive function to partition
// a string in every possible substrings
void print1(string m, int index, string ans)
{
     
    // If index = m.length, check if ans
    // forms an increasing sequence or not
    if (index == m.length())
    {
     
        if (check(ans))
        {
         
            // Increment count by 1,
            // if sequence is increasing
            count1++;
        }
        return;
    }  
 
    // If S[index] is appended to previous number
    print1(m, index + 1, ans + m[index]);
     
    if (index != 0)
     
        // If S[index] is starting a new number
        print1(m, index + 1,
              ans + " " + m[index]);
}
 
// Driver Code
int main()
{
     
    // Given Input
    string k = "1345";
     
    // Function Call
    print1(k, 0, "");
     
    // Print the answer.
    cout << count1;
}
 
// This code is contributed by ipg2016107

Java

// Java program for the above approach
 
import java.io.*;
import java.util.*;
class GFG {
 
    // Stores the number of ways
    // to partition a string
    static int count = 0;
 
    // Function to check if a sequence
    // is strictly increasing or not
    static boolean check(String m)
    {
        // If there is only one number
        if (m.length() == 1) {
            return true;
        }
 
        // Split the string m when there is space
        String temp[] = m.split(" ");
        int number[] = new int[temp.length];
 
        // Insert all the splits into the array
        for (int i = 0; i < temp.length; ++i) {
 
            number[i] = Integer.parseInt(temp[i]);
        }
 
        int first = number[0];
        for (int i = 1; i < number.length; ++i) {
 
            if (number[i] > first) {
                first = number[i];
            }
            else {
 
                // If number is not increasing
                return false;
            }
        }
 
        // If the sequence is increasing
        return true;
    }
 
    // Recursive function to partition
    // a string in every possible substrings
    static void print(String m,
                      int index, String ans)
    {
        // If index = m.length, check if ans
        // forms an increasing sequence or not
        if (index == m.length()) {
 
            if (check(ans)) {
 
                // Increment count by 1,
                // if sequence is increasing
                ++count;
            }
            return;
        }
 
        // If S[index] is appended to previous number
        print(m, index + 1, ans + m.charAt(index));
        if (index != 0)
            // If S[index] is starting a new number
            print(m, index + 1,
                  ans + " " + m.charAt(index));
    }
 
    // DriverCode
    public static void main(String[] args)
    {
        // Given Input
        String k = Integer.toString(1345);
 
        // Function Call
        print(k, 0, "");
 
        // Print the answer.
        System.out.println(count);
    }
}

Python3

# Python3 program for the above approach
count = 0
  
# Function to check if a sequence
# is strictly increasing or not
def check(m):
   
    # If there is only one number
    if (len(m) == 1):
        return True
 
    # Split the string m when there is space
    temp = m.split(" ")
    number = [0]*(len(temp))
 
    # Insert all the splits into the array
    for i in range(len(temp)):
        number[i] = int(temp[i])
 
    first = number[0]
    for i in range(1, len(number)):
        if (number[i] > first):
            first = number[i]
        else:
            # If number is not increasing
            return False
    # If the sequence is increasing
    return True
 
# Recursive function to partition
# a string in every possible substrings
def Print(m, index, ans):
    global count
     
    # If index = m.length, check if ans
    # forms an increasing sequence or not
    if (index == len(m)):
        if (check(ans)):
           
            # Increment count by 1,
            # if sequence is increasing
            count+=1
        return
 
    # If S[index] is appended to previous number
    Print(m, index + 1, ans + m[index])
    if (index != 0):
       
        # If S[index] is starting a new number
        Print(m, index + 1, ans + " " + m[index])
 
# Given Input
k = "1345"
  
# Function Call
Print(k, 0, "")
  
# Print the answer.
print(count)
 
# This code is contributed by suresh07.

C#

using System;
 
public class GFG {
    static int count = 0;
 
    // Function to check if a sequence
    // is strictly increasing or not
    static bool check(String m)
    {
        // If there is only one number
        if (m.Length == 1) {
            return true;
        }
 
        // Split the string m when there is space
        String[] temp = m.Split(" ");
        int[] number = new int[temp.Length];
 
        // Insert all the splits into the array
        for (int i = 0; i < temp.Length; ++i) {
 
            number[i] = int.Parse(temp[i]);
        }
 
        int first = number[0];
        for (int i = 1; i < number.Length; ++i) {
 
            if (number[i] > first) {
                first = number[i];
            }
            else {
 
                // If number is not increasing
                return false;
            }
        }
 
        // If the sequence is increasing
        return true;
    }
 
    // Recursive function to partition
    // a string in every possible substrings
    static void print(String m, int index, String ans)
    {
        // If index = m.length, check if ans
        // forms an increasing sequence or not
        if (index == m.Length) {
 
            if (check(ans)) {
 
                // Increment count by 1,
                // if sequence is increasing
                ++count;
            }
            return;
        }
 
        // If S[index] is appended to previous number
        print(m, index + 1, ans + m[index]);
        if (index != 0)
            // If S[index] is starting a new number
            print(m, index + 1, ans + " " + m[index]);
    }
    static public void Main()
    {
 
        String k = "1345";
 
        // Function Call
        print(k, 0, "");
 
        // Print the answer.
        Console.WriteLine(count);
    }
}
 
// This code is contributed by maddler.

Javascript

 
// JavaScript program for the above approach
 
// Stores the number of ways
// to partition a string
let count = 0;
 
// Function to check if a sequence
// is strictly increasing or not
function check(m)
{
     
    // If there is only one number
    if (m.length == 1)
    {
        return true;
    }
 
    // Split the string m when there is space
    let temp = m.split(" ");
    let number = new Array(temp.length);
 
    // Insert all the splits into the array
    for(let i = 0; i < temp.length; ++i)
    {
        number[i] = parseInt(temp[i]);
    }
     
    let first = number[0];
    for(let i = 1; i < number.length; ++i)
    {
        if (number[i] > first)
        {
            first = number[i];
        }
        else
        {
             
            // If number is not increasing
            return false;
        }
    }
     
    // If the sequence is increasing
    return true;
}
 
// Recursive function to partition
// a string in every possible substrings
function print(m, index, ans)
{
     
    // If index = m.length, check if ans
    // forms an increasing sequence or not
    if (index == m.length)
    {
        if (check(ans))
        {
             
            // Increment count by 1,
            // if sequence is increasing
            ++count;
        }
        return;
    }
 
    // If S[index] is appended to previous number
    print(m, index + 1, ans + m[index]);
     
    if (index != 0)
     
        // If S[index] is starting a new number
        print(m, index + 1,
              ans + " " + m[index]);
}
 
// Driver Code
 
// Given Input
let k = "1345";
 
// Function Call
print(k, 0, "");
 
// Print the answer.
document.write(count);
 
// This code is contributed by code_hunt
 

输出：

5

时间复杂度： O(N*2 ^N ) 其中 N 是字符串S 的长度
辅助空间： O(1)