给定一个二进制字符串str 。任务是找到最小的正整数C ，使得二进制字符串可以被切成C 个片段(子字符串)，每个子字符串应该是 5 的幂，没有前导零。
例子：
Input: str = “101101101”
Output: 3
The string “101101101” can be cut into three binary strings “101”, “101”, “101”
each of which is a power of 5.
Input: str = “1111101”
Output: 1
The string “1111101” can be cut into one binary string “1111101” which is
125 in decimal and a power of 5.
Input: str = “00000”
Output: -1
Strings of only zeroes is equivalent to 0 which is not a power of 5.
方法：这个问题是最长递增子序列的简单变体。
从i = 1 开始迭代，对于每个str[j…i]其中j = 0 & j < i ，我们检查从str[j..i]形成的数字是否是5的幂，然后我们更新dp[]数组具有可能的最低切割尺寸值的值。在确认由十进制str[j..i]形成的数字是5的幂后，我们计算dp[i] = min(dp[i], dp[j] + 1) 。
这种技术与寻找最长递增子序列非常相似。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
#define ll unsigned long long
// Function that returns true
// if n is a power of 5
bool ispower(ll n)
{
if (n < 125)
return (n == 1 || n == 5 || n == 25);
if (n % 125 != 0)
return false;
else
return ispower(n / 125);
}
// Function to return the decimal
// value of binary equivalent
ll number(string s, int i, int j)
{
ll ans = 0;
for (int x = i; x < j; x++) {
ans = ans * 2 + (s[x] - '0');
}
return ans;
}
// Function to return the minimum cuts required
int minCuts(string s, int n)
{
int dp[n + 1];
// Allocating memory for dp[] array
memset(dp, n + 1, sizeof(dp));
dp[0] = 0;
// From length 1 to n
for (int i = 1; i <= n; i++) {
// If previous character is '0' then ignore
// to avoid number with leading 0s.
if (s[i - 1] == '0')
continue;
for (int j = 0; j < i; j++) {
// Ignore s[j] = '0' starting numbers
if (s[j] == '0')
continue;
// Number formed from s[j....i]
ll num = number(s, j, i);
// Check for power of 5
if (!ispower(num))
continue;
// Assigning min value to get min cut possible
dp[i] = min(dp[i], dp[j] + 1);
}
}
// (n + 1) to check if all the strings are traversed
// and no divisible by 5 is obtained like 000000
return ((dp[n] < n + 1) ? dp[n] : -1);
}
// Driver code
int main()
{
string s = "101101101";
int n = s.length();
cout << minCuts(s, n);
return 0;
} Java
// Java implementation of the approach
import java.util.*;
class GFG
{
// Function that returns true
// if n is a power of 5
static boolean ispower(long n)
{
if (n < 125)
{
return (n == 1 || n == 5 || n == 25);
}
if (n % 125 != 0)
{
return false;
}
else
{
return ispower(n / 125);
}
}
// Function to return the decimal
// value of binary equivalent
static long number(String s, int i, int j)
{
long ans = 0;
for (int x = i; x < j; x++)
{
ans = ans * 2 + (s.charAt(x) - '0');
}
return ans;
}
// Function to return the minimum cuts required
static int minCuts(String s, int n)
{
int[] dp = new int[n + 1];
// Alongocating memory for dp[] array
Arrays.fill(dp, n+1);
dp[0] = 0;
// From length 1 to n
for (int i = 1; i <= n; i++)
{
// If previous character is '0' then ignore
// to avoid number with leading 0s.
if (s.charAt(i - 1) == '0')
{
continue;
}
for (int j = 0; j < i; j++)
{
// Ignore s[j] = '0' starting numbers
if (s.charAt(j) == '0')
{
continue;
}
// Number formed from s[j....i]
long num = number(s, j, i);
// Check for power of 5
if (!ispower(num))
{
continue;
}
// Assigning min value to get min cut possible
dp[i] = Math.min(dp[i], dp[j] + 1);
}
}
// (n + 1) to check if all the Strings are traversed
// and no divisible by 5 is obtained like 000000
return ((dp[n] < n + 1) ? dp[n] : -1);
}
// Driver code
public static void main(String[] args)
{
String s = "101101101";
int n = s.length();
System.out.println(minCuts(s, n));
}
}
// This code is contributed by 29AjayKumarPython 3
# Python 3 implementation of the approach
# Function that returns true
# if n is a power of 5
def ispower( n):
if (n < 125):
return (n == 1 or n == 5 or n == 25)
if (n % 125 != 0):
return 0
else:
return ispower(n // 125)
# Function to return the decimal
# value of binary equivalent
def number(s, i, j):
ans = 0
for x in range( i, j) :
ans = ans * 2 + (ord(s[x]) - ord('0'))
return ans
# Function to return the minimum cuts required
def minCuts(s, n):
# Allocating memory for dp[] array
dp=[n+1 for i in range(n+1)]
dp[0] = 0;
# From length 1 to n
for i in range(1, n+1) :
# If previous character is '0' then ignore
# to avoid number with leading 0s.
if (s[i - 1] == '0'):
continue
for j in range(i) :
# Ignore s[j] = '0' starting numbers
if (s[j] == '0'):
continue
# Number formed from s[j....i]
num = number(s, j, i)
# Check for power of 5
if (not ispower(num)):
continue
# Assigning min value to get min cut possible
dp[i] = min(dp[i], dp[j] + 1)
# (n + 1) to check if all the strings are traversed
# and no divisible by 5 is obtained like 000000
if dp[n] < n + 1:
return dp[n]
else:
return -1
# Driver code
if __name__== "__main__":
s = "101101101"
n = len(s)
print(minCuts(s, n))
# This code is contributed by ChitraNayalC#
// C# implementation of the approach
using System;
class GFG
{
// Function that returns true
// if n is a power of 5
static Boolean ispower(long n)
{
if (n < 125)
{
return (n == 1 || n == 5 || n == 25);
}
if (n % 125 != 0)
{
return false;
}
else
{
return ispower(n / 125);
}
}
// Function to return the decimal
// value of binary equivalent
static long number(String s, int i, int j)
{
long ans = 0;
for (int x = i; x < j; x++)
{
ans = ans * 2 + (s[x] - '0');
}
return ans;
}
// Function to return the minimum cuts required
static int minCuts(String s, int n)
{
int[] dp = new int[n + 1];
// Alongocating memory for dp[] array
for (int i = 0; i <= n; i++)
dp[i]=n+1;
dp[0] = 0;
// From length 1 to n
for (int i = 1; i <= n; i++)
{
// If previous character is '0' then ignore
// to avoid number with leading 0s.
if (s[i - 1] == '0')
{
continue;
}
for (int j = 0; j < i; j++)
{
// Ignore s[j] = '0' starting numbers
if (s[j] == '0')
{
continue;
}
// Number formed from s[j....i]
long num = number(s, j, i);
// Check for power of 5
if (!ispower(num))
{
continue;
}
// Assigning min value to get min cut possible
dp[i] = Math.Min(dp[i], dp[j] + 1);
}
}
// (n + 1) to check if all the Strings are traversed
// and no divisible by 5 is obtained like 000000
return ((dp[n] < n + 1) ? dp[n] : -1);
}
// Driver code
public static void Main(String[] args)
{
String s = "101101101";
int n = s.Length;
Console.WriteLine(minCuts(s, n));
}
}
/* This code contributed by PrinciRaj1992 */PHP
Javascript
输出：
3时间复杂度： O(n 2 )
空间复杂度： O(n)
如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。