「最大子串和java」最大子串和递推公式
今天给各位分享最大子串和java的知识，其中也会对最大子串和递推公式进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、获取最大长度存在巅倒字符串的子串
- 2、java程序题(高手帮个忙)
- 3、用java编写输入两个字符串输出最大相同字符串
- 4、最大连续子串的长度-动态规划
- 5、java 编写一个方法,找出一个字符串中最长的回文子串
- 6、在整型数组里找出和值最大（最长）的“子串”，要求用C实现
获取最大长度存在巅倒字符串的子串
/*******************************************************************************
* @Description 字符串操作类
* @Author
* @Date / /
******************************************************************************/
public class StringX {
/*
* @Function 从指定字符串中获取最大长度存在巅倒字符串的子串
* @Parm str String 源字符串
* @Return 存在巅倒字符串的最大子串 存在多个时 仅返回最右边的一个
*/
public String getMaxLenReverseString(String str) {
int startIndex = ;
int lenOfReverseStr = ;
int tmp = ;
for ( int i = lenOfReverseStr; i = str length(); i++ ) {
tmp = getPosOfReverseString(str i);
if ( tmp != ) {
lenOfReverseStr = i;
startIndex = tmp;
str = str substring( tmp + lenOfReverseStr);
} else {
break;
}
}
return startIndex == ? str substring( ) : str substring(startIndex startIndex + lenOfReverseStr);
}
/*
* @Function 从指定字符串中 获得最右边特定长度存在其巅倒字符串的子串的起始位置
* @Parm str String 源字符串 将从中获取存在巅倒字符串的子串
* @Parm lenOfReverseStr int 巅倒字符串的长度
* @Return int 存在巅倒字符串的子串的起始位置 如不存在子串的巅倒字符串或参数错误 才返回
*/
public int getPosOfReverseString(String str int lenOfReverseStr) {
if ( lenOfReverseStr str length() || lenOfReverseStr ) {
return ;
}
for ( int i = str length() lenOfReverseStr; i = ; i ) {
if ( str indexOf(getReverseString(str i lenOfReverseStr)) != ) {
return i;
}
}
return ;
}
/*
* @Function 从指定字符串中得到其子串的巅倒字符串
* @Parm str String 源字符串 将从中获得巅倒字符串
* @Parm s int 将被巅倒子串在源字符串中的起始位置
* @Parm len int 将被巅倒子串的长度
* @Return String 巅倒后得到的字符串 如参数错误就返回空字符串
*/
public String getReverseString(String str int s int len) {
int tmp = s + len;
if ( tmp str length() || tmp || s * len ) {
return ;
}
StringBuilder reverseStr = new StringBuilder(len);
for ( int i = s + len ; i = s; i ) {
reverseStr append(str charAt(i));
}
return reverseStr toString();
}
public static void main(String[] args) {
StringX objTest = new StringX();
System out println(objTest getMaxLenReverseString( ARSTUVYWFDEVUTSRZ ));
System out println(objTest getMaxLenReverseString( ABC ));
System out println(objTest getMaxLenReverseString( DEFDEDJH ));
System out println(objTest getMaxLenReverseString( HIJKLKJIH ));
}
lishixinzhi/Article/program/Java/hx/201311/25702
java程序题(高手帮个忙)
public class StringScan {
public static void main(String[] args) {
System.out.println(f3701("aaabbbdsdas"));
}
public static int f3701(String input){
int max = 1;
int size = input.length();
char [] data = input.toCharArray();
char maxChar = ' ';
int count;
for(int i=0;isize;i++){
count = 0;
for(int j=0;jsize;j++){
if(data[i] != maxChar data[i] == data[j]){
count++;
}
}
if(count max ){
max = count;
maxChar = data[i];
}
}
return max;
}
}
用java编写输入两个字符串输出最大相同字符串
这种东西一搜一大堆啊
public class LCString3 {
public static void getLCString(char[] str1, char[] str2) {
int i, j;
int len1, len2;
len1 = str1.length;
len2 = str2.length;
int maxLen = len1 len2 ? len1 : len2;
int[] max = new int[maxLen];
int[] maxIndex = new int[maxLen];
int[] c = new int[maxLen];
for (i = 0; i len2; i++) {
for (j = len1 - 1; j = 0; j--) {
if (str2[i] == str1[j]) {
if ((i == 0) || (j == 0))
c[j] = 1;
else
c[j] = c[j - 1] + 1;
} else {
c[j] = 0;
}
if (c[j] max[0]) { // 如果是大于那暂时只有一个是最长的,而且要把后面的清0;
max[0] = c[j];
maxIndex[0] = j;
for (int k = 1; k maxLen; k++) {
max[k] = 0;
maxIndex[k] = 0;
}
} else if (c[j] == max[0]) { // 有多个是相同长度的子串
for (int k = 1; k maxLen; k++) {
if (max[k] == 0) {
max[k] = c[j];
maxIndex[k] = j;
break; // 在后面加一个就要退出循环了
}
}
}
}
}
for (j = 0; j maxLen; j++) {
if (max[j] 0) {
System.out.println("第" + (j + 1) + "个公共子串:");
for (i = maxIndex[j] - max[j] + 1; i = maxIndex[j]; i++)
System.out.print(str1[i]);
System.out.println(" ");
}
}
}
public static void main(String[] args) {
String str1 = new String("helloworld");
String str2 = new String("hello,world");
getLCString(str1.toCharArray(), str2.toCharArray());
}
}
最大连续子串的长度-动态规划
字符串的最大连续子串的长度，子串不能有重复字符,例如
输入："abcabcbb"
输出：3
输入："bbbbb"
输出：1
输入："pwwkew"
输出：3
使用动态规划来解决问题，先找到状态转移方程
时间复杂度O(n)
java 编写一个方法,找出一个字符串中最长的回文子串
Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import java.util.ArrayList;
import java.util.List;
public class Palindrome {
/* 找出一个字符串中最长的回文子串
* 从字符串中第i个字符开始的所有非空回文子串的个数, 记作为Ci. 此方法的复杂度为
* O(C1 + C2 + ... + Cn)
* 当字符串中任意两个非空回文子串的起始位置不同时, C1 = C2 = ... = Cn = 1, 复杂度为O(N);
* 当字符串所有字符均为同一字符时, Ci = n - i, 此时复杂度为O(N*N);
* 在多数情况下, 此方法的复杂度远低于O(N*N).
*/
public ListString getLongestPalindrome(String theString) {
int strLen = theString.length();
ListString results = new ArrayListString(strLen);
if (strLen == 0) {
return results;
}
// 从第i个位置开始的所有回文子串的结束位置.
int[] endIndice = new int[strLen + 1];
// endIndice中有效数据的长度.
int numberOfPalindromes = 1;
// 最长回文子串的长度. 对于非空串至少可以找到长度为1的回文子串.
int maxLen = 1;
results.add(theString.substring(strLen - 1));
// 计算从第i个位置开始的所有回文子串. 这样的子串分为三种:
// 1. 在从第i+1个位置开始的回文子串的基础上, 在两端加上相同的字符;
// 2. 长度为1的回文子串;
// 3. 空串.
for (int i = strLen - 2; i = 0; i--) {
int j = 0, k = 0;
while (j numberOfPalindromes) {
if (theString.charAt(i) == theString.charAt(endIndice[j])) {
endIndice[k] = endIndice[j] + 1;
int newLength = endIndice[k] - i;
if (newLength = maxLen) {
if (newLength maxLen) {
maxLen = newLength;
results.clear();
}
results.add(theString.substring(i, endIndice[k]));
}
if (endIndice[k] strLen) {
k++;
}
}
j++;
}
// 加入长度为1的子串
endIndice[k++] = i + 1;
if (maxLen == 1) {
results.add(theString.substring(i, i + 1));
}
// 加入空串
endIndice[k++] = i;
numberOfPalindromes = k;
}
return results;
}
public static void main(String[] args) {
Palindrome p = new Palindrome();
printList(p.getLongestPalindrome("gabcecbaefd"));
printList(p.getLongestPalindrome("bbcbaefccfg"));
printList(p.getLongestPalindrome("aaaaaaaaaaa"));
printList(p.getLongestPalindrome("abcdefghijk"));
printList(p.getLongestPalindrome("abcdeeddejk"));
printList(p.getLongestPalindrome(""));
}
public static void printList(List? extends Object list) {
System.out.println("**************************");
System.out.println(list.size() + " result(s):");
for (Object o : list) {
System.out.println(o);
}
}
}
在整型数组里找出和值最大（最长）的“子串”，要求用C实现
/***********************************
输入包括两行，第一行为数组的长度，
第二行为数组的各个元素以空格分隔。
输出为和最大（最长）的子串。
例如：
输入：6
-1 3 6 -2 7 0
输出：3 6 -2 7 0
************************************/
#includestdio.h
main()
{
int a[80];
int n;
int i,j,k;
int max=0,sum=0;
int begin,end;
scanf("%d",n);
for (i=0;in ;i++ )scanf("%d",a[i]);
for(i=0;in-1;i++)for(j=i+1;jn;j++)
{
for(k=i;k=j;k++)sum+=a[k];
if(sum==max)
if(j-iend-begin)
{
begin=i;
end=j;
}
if(summax)
{
max=sum;
begin=i;
end=j;
}
sum=0;
}
for(i=begin;i=end;i++)printf("%d ",a[i]);
printf("\n");
}
关于最大子串和java和最大子串和递推公式的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-12-29，除非注明，否则均为原创文章，转载请注明出处。