精华内容
下载资源
问答
  • 最长重复子串问题求大神指点想要把一个字符串中重复最长的部分提取出来,比如说有如下字符串:abcdbcdbcb对于这个字符串最长的重复子串为bcdbc!查了下网上的解答,代码如下#include#include#include#defineMAXCHAR...

    最长重复子串问题

    求大神指点

    想要把一个字符串中重复最长的部分提取出来,比如说有如下字符串:

    abcdbcdbcb

    对于这个字符串最长的重复子串为bcdbc!

    查了下网上的解答,代码如下

    #include 

    #include 

    #include 

    #define MAXCHAR 5000 //最长处理5000个字符

    char c[MAXCHAR], *a[MAXCHAR];

    int comlen( char *p, char *q ){

    int i = 0;

    while( *p && (*p++ == *q++) )

    ++i;

    return i;

    }

    int pstrcmp( const void *p1, const void *p2 ){    // 这个函数是什么意思,参数看不懂

    return strcmp( *(char* const *)p1, *(char* const*)p2 );

    }

    int main(  ){

    char ch;

    int  n=0;

    int  i, temp;

    int  maxlen=0, maxi=0;

    printf("Please input your string:\n");

    while( (ch=getchar())!='\n' ){

    a[n]=&c[n];

    c[n++]=ch;

    }

    c[n]='\0';

    qsort( a, n, sizeof(char*), pstrcmp );   // 这里的快速排序是对什么排序

    for(i=0; i

    temp=comlen( a[i], a[i+1] );

    if( temp>maxlen ){

    maxlen=temp;

    maxi=i;

    }

    }

    printf("%.*s\n",maxlen, a[maxi]);

    system("PAUSE");

    return 0;

    }

    但是这个代码看不懂,求大神指点

    分享到:

    ------解决方案--------------------

    int pstrcmp( const void *p1, const void *p2 ){//该函数是qsort函数的“回调”函数。两个参数的类型为指向常量的无类型指针

    return strcmp( *(char* const *)p1, *(char* const*)p2 );//将参数强制类型转换为char* const *类型,然后取其值,其值为char* const类型。

    }

    ------解决方案--------------------

    引用:Quote: 引用:int pstrcmp( const void *p1, const void *p2 ){//该函数是qsort函数的“回调”函数。两个参数的类型为指向常量的无类型指针

    return strcmp( *(char* const *)p1, *(char* const*)p2 );//将参数强制类型转换为char* const *类型,然后取其值,其值为char* const类型。

    }

    pstrcmp为什么在qsort里面没有参数

    函数指针,这时windows 回调函数 的传递方式

    对于C 就是函数指针,实参用函数地址,而函数名可以代表它的地址。

    qsort 的实现代码里会通过函数指针,调用这个函数。

    qsort VC有源码,当比较元素时,会调用实参 ,调用时比较函数的参数就是,被比较的两个数据.

    展开全文
  • 最长重复子串问题

    2021-03-10 07:13:27
    经典问题,记录一下这道题解法问题描述给定一个字符串,找到最长子串的长度,要求子串不含不重复字符。样例给定"pwkpwo"的答案是是4("kpwo")。给定"bbbbb"的答案是1("b")。解法1.双指针-滑动窗口i:表示窗口左端点j...

    经典问题,记录一下这道题解法

    问题描述

    给定一个字符串,找到最长子串的长度,要求子串不含不重复字符。

    样例

    给定"pwkpwo"的答案是是4("kpwo")。

    给定"bbbbb"的答案是1("b")。

    解法

    1.双指针-滑动窗口

    i:表示窗口左端点

    j:表示窗口右端点

    set存储s[i]到s[j]间的字符

    如果没有重复字符,那么将当前窗口大小与目前最长的子串长度比较并更新,j++;

    如果有重复字符,那么将窗口左端点右移,i++,直到窗口内不含重复字符,执行上一行

    复杂度:

    遍历一遍字符串s为O(n),而set里极端情况下也只存128个字符,所以插入删除是O(1)的,总的复杂度就是O(n)

    public class Solution {

    public int lengthOfLongestSubstring(String s) {

    int n = s.length();

    Set set = new HashSet<>();

    int ans = 0, i = 0, j = 0;

    while (i < n && j < n) {

    // try to extend the range [i, j] if (!set.contains(s.charAt(j))){

    set.add(s.charAt(j++));

    ans = Math.max(ans, j - i);

    }

    else {

    set.remove(s.charAt(i++));

    }

    }

    return ans;

    }

    }

    2.改进版滑动窗口

    相比于上一种方法,改良的代码里用一个map去存各字符最近出现位置的下一个位置,好处是滑动窗口的左边缘i不用再一步步地挪了,直接一步到位

    public class Solution {

    public int lengthOfLongestSubstring(String s) {

    int n = s.length(), ans = 0;

    Map map = new HashMap<>();

    for (int j = 0, i = 0; j < n; j++) {

    if (map.containsKey(s.charAt(j))) {

    i = Math.max(map.get(s.charAt(j)), i);

    }

    ans = Math.max(ans, j - i + 1);

    map.put(s.charAt(j), j + 1);

    }

    return ans;

    }

    }

    举个栗子

    s="pwkpwo"

    (1)最初,map为空,i=j=0,ans=窗口大小=j-i+1=1,更新map,记录'p'最近出现位置的下一个位置为:1

    (2)i=0,j=1,窗口内无重复字符,ans=窗口大小=2,记录'w'最近出现位置的下一个位置为:2

    (3))i=0,j=2,窗口内无重复字符,ans=窗口大小=3,记录'k'最近出现位置的下一个位置为:3

    (4))i=0,j=3,s[j]与先前窗口内字符重复,因此需要将窗口左端点移动到让窗口不含'p'的最小位置(即map.get('p')),更新后i=1,这样s[i]到s[j]间又没有重复字符串了;同时更新'p'最近出现位置的下一个位置为:4

    更新i后:

    后边就不再解释了

    总之这种方法的改进就是在窗口内字符与s[j]重复时,把窗口左端点一步一步挪动改进成了一步到位,但是本质上复杂度还是没有改变,依旧是O(n)

    查找最长子串的长度(不重复字符) - linghu_java - 博客园​www.cnblogs.com

    展开全文
  • 最长重复子串的算法

    2021-01-05 18:42:47
    最长重复子串的算法 public class StrTest { @Test public void longDoubSubStr(){ String str = "eabcdabcfeabeabeabeab"; String longDoubSubStr1 = findLongestSubString(str); System.out.println(...

    求最长重复子串的算法

    public class StrTest {
    
        @Test
        public void longDoubSubStr(){
            String str = "eabcdabcfeabeabeabeab";
            String longDoubSubStr1 = findLongestSubString(str);
            System.out.println("longDoubSubStr1:"+longDoubSubStr1);
    
            String longDoubSubStr2 = findSubStr(str);
            System.out.println("longDoubSubStr2:"+longDoubSubStr2);
    
            String longDoubSubStr3 = findSubStrByNxt(str);
            System.out.println("longDoubSubStr3:"+longDoubSubStr3);
        }
    
        private String findSubStrByNxt(String str) {
    
            int maxPos = 0;
            int maxReStrLen = 0;
            /**
             * 使用KMP算法:依次去掉str最前端的i个字符,计算余下子串的next[]数组,数组的最大指,即为最大子串长度,
             * 并根据得到最大子串时的位置的i值,获取最大子串
             */
            for (int pos = 0; pos < str.length(); pos++){
                String subStrTem = str.substring(pos);
                /**
                 *
                 */
                int reStrLen = calcNxtArry(subStrTem);
                if (reStrLen > maxReStrLen){
                    maxReStrLen = reStrLen;
                    maxPos = pos;
                }
    
            }
            /**
             * 从maxSubStrLenSubInfo中解析出重复的最长子串信息
             */
    
            return str.substring(maxPos, maxPos + maxReStrLen);
        }
    
        private int calcNxtArry(String subStrTem) {
    
            int maxReStrLen = 0;
            int reStrLen = 0;
            int preIndexReStrLen = 0;
            for (int index = 0; index < subStrTem.length(); index++){
                reStrLen = getNxt(index, subStrTem, preIndexReStrLen);
                if (maxReStrLen < reStrLen){
                    maxReStrLen = reStrLen;
                }
                preIndexReStrLen = reStrLen;
            }
    
            return maxReStrLen;
        }
    
        private int getNxt(int index, String subStrTem, int preIndexReStrLen) {
            int subStrLen = 0;
            if (index == 0){
                return 0;
            }
    
    
            /**
             * 以下的逻辑可以优化:
             * 1)记录前一index对应的preindex_subStrLen,subStrLen = preindex_subStrLen +1 开始循环
             */
    		//        for(subStrLen = index; subStrLen > 0; subStrLen--){
    //            if (subStrTem.substring(0, subStrLen).equals(subStrTem.substring(index - subStrLen + 1, index + 1))){
    //                break;
    //            }
    //        }
    
            for(subStrLen = preIndexReStrLen +1; subStrLen > 0; subStrLen--){
                if (subStrTem.substring(0, subStrLen).equals(subStrTem.substring(index - subStrLen + 1, index + 1))){
                    break;
                }
            }
            return subStrLen;
        }
    
        /**
         * 简化的三层循环
         * @param str
         * @return
         */
        private String findLongestSubString(String str) {
    
    
            int maxSubStrLen = 0;
            int maxSubStrPos = 0;
            /**
             * 对str有效性做检验
             */
            if(!checkValid(str)){
                return null;
            }
            /**
             * 双重遍历,寻找存在的重复子串,并记录重复子串长度:
             *      外重循环:两个子串起始坐标的间隔,从(1,len(str)-1)
             *      内重循环:从源串的起始位置,依次往后遍历
             * 维护找到的最长重复子串的长度以及起始位置。
             */
            int strLength = str.length();
            for (int interval = 1; interval < strLength; interval++){
    
                for (int pos = 0; pos + interval < strLength; pos++){
    
                    int subStrLen = 0;
    
                    try {
                        while (str.charAt(pos + subStrLen) == str.charAt(pos + interval + subStrLen)){
                            subStrLen++;
                            if (pos + interval + subStrLen >= strLength){
                                break;
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        System.out.println("pos: "+pos+"; interval: "+interval);
                    }
    
                    if (subStrLen > maxSubStrLen){
                        maxSubStrLen = subStrLen;
                        maxSubStrPos = pos;
                    }
    
                }
            }
            /**
             * 构造子串,返回
             */
            return str.substring(maxSubStrPos, maxSubStrPos+maxSubStrLen);
        }
    
        private boolean checkValid(String str) {
            return StringUtils.isNotBlank(str);
        }
    
        /***
         * 原始的三层循环
         */
        private String findSubStr(String str){
    
            /**
             * 定义重复出现的最大子串
             */
            String maxSubStr = "";
            /**
             * 定义内层循环找到重复子串的标记,默认false,为找到,内层循环一旦找到,就跳出外层循环
             */
            boolean gotFlag = false;
            /**
             * 遍历所有可能的最大长度,理论最大值len(str)-1
             */
            for (int subStrLen = str.length()-1; subStrLen > 0; subStrLen--){
                /**
                 * 遍历str中所有长度为subStrLen的数组,验证是否重复
                 */
                for (int pos = 0; pos + subStrLen < str.length(); pos++){
    
                    /**
                     * 得到子串
                     */
                    String subStr = str.substring(pos, pos+subStrLen);
                    /**
                     * 得到str首次出现子串的起始坐标
                     */
                    int pos_fix = str.indexOf(subStr);
                    /**
                     * 得到str末次出现子串的起始坐标
                     */
                    int pos_post = str.lastIndexOf(subStr);
    
                    /**
                     * 两者不相等则说明重复出现
                     */
                    if (pos_fix != pos_post){
                        maxSubStr = subStr;
                        gotFlag = true;
                        break;
                    }
    
                }
    
                if (gotFlag == true){
                    break;
                }
            }
            return maxSubStr;
        }
    
    }
    
    展开全文
  • 最长连续不重复子串

    2021-01-28 09:13:06
    给定一个字符串,找出不含有重复字符的最长子串的长度。 示例: 给定 “abcabcbb” ,没有重复字符的最长子串是 “abc” ,那么长度就是3。 给定 “bbbbb” ,最长子串就是 “b” ,长度是1。 给定 “pwwkew” ,...

    题目内容

    描述

    给定一个字符串,找出不含有重复字符的最长子串的长度。

    示例:

    给定 “abcabcbb” ,没有重复字符的最长子串是 “abc” ,那么长度就是3。

    给定 “bbbbb” ,最长的子串就是 “b” ,长度是1。

    给定 “pwwkew” ,最长子串是 “wke” ,长度是3。请注意答案必须是一个子串,”pwke” 是 子序列 而不是子串。

    代码:

    # include <iostream>
    # include <string>
    using namespace std;
    int cnt[10000];
    int ans = 0;
    int ed = -1;
    int main(void)
    {
        string s;;
        cin>>s;
        
        for(int l=0,r=0;r<s.size();){
            cnt[s[r++]-'a']++;          //这个cnt就是记录窗口内各个元素的个数
            while(l<r && cnt[s[r-1]-'a']>1){ 
                cnt[s[l]-'a']--;
                ++l;
            }
            if(ans<(r-l)){
                ed = r-1;   //记录下标
                ans = r-l;   //记录长度
            }
        }
        
        for(int i=ed-ans+1;i<=ed;++i){
            cout<<s[i]<<' ';
        }cout<<endl;
        return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 动态规划 最长重复连续子串,规划最长题意Longest Substring Without Repeating CharactersGiven a string, find the length of the longest substring without repeating characters. For example, the longest ...
  • 记录一下自己刷题的算法,题目来源LeetCode(力扣)给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。示例 1:输入: "abcabcbb"输出: 3解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。示例 2:...
  • 重复字符的最长子串 import java.util.HashMap; public class Solution { public int lengthOfLongestSubstring(String s){ if(s.length() == 0){ return 0; } HashMap map = new HashMap(); int max = 0; int ...
  • 本文实例讲述了Python简单实现查找一个字符串中最长重复子串的方法。,具体如下:刚结束的一个笔试题,很简单,不多说简单贴一下具体的实现:#!usr/bin/env python#encoding:utf-8'''''__Author__:沂水寒城功能:...
  • } //O(N^2)的时间复杂度 static void max_unique(String str) { // begin用来保存 最长重复子串的 开始索引 int begin=0; // maxlen用来保存最长重复子串的 长度 int maxlen = 0; // 定义一个容器,用来保存...
  • 题目给定一个字符串,请从这个字符串中找出所有最长的没有重复字符的子串,并返回最长重复子串的长度。例如:字符串:mabcafrab ==> 最长重复子串:bcafr,长度5字符串:pwswekedw ==> 最长重复子串:...
  • 有时候面试会问到的一道题目,当然问法可能不一样,最长的连续子串,也是同样的逻辑 <?php $string = "cbacmcdaefaeadkqatlmtx"; // 获取字符串场地 $len = strlen($string); // 最长字符串 $maxArr = []; // ...
  • 依次类推…直至取到字符串的最后一个字符,记录下最后一串未出现重复字符的子串长度,和之前的最长子串长度进行比较,返回较大的值。 3.解题: /*** 这里的算法类似简单的插入排序: * 取出字符串中的第i个字符,...
  • leetcode 最长重复子串: 利用hash表解决: class Solution { public: int lengthOfLongestSubstring(string s) { int begin(0), end(0); int sSize = int(s.size()); int len=0; int maxLen = 0; unordered...
  • publicstaticvoidlongestNodupSubstring(Stringstring){intlen=string.length();if(len>0){Mapcursor=newHashMap();cursor.put(string.charAt...public static void longestNodupSubstring(String string) {int l...
  • /** the basic idea is, keep a hashmap which stores the characters in string as keys* and their positions as values, and keep two pointers which define the max substring.* move the right pointer to sca...
  • 问题描述:有两个字符串str和str2,求出两个字符串中最长公共子串长度。str=acbcbcef,str2=abcbced,则str和str2的最长公共子串为bcbce,最长公共子串长度为5。 算法思路: 把两个字符串分别以行和列组成一个二维...
  • 问题描述:输入一个字符串,输出该字符串中最大对称子串的长度。例如输入字符串:“avvbeeb”,该字符串中最长的子字符串是“beeb”,长度为4,因而输出为4。解决方法:中序遍历一,全遍历的方法:1.全遍历的方法,...
  • 求一个字符串的最长重复子串。比如:给定"abcabcbb"的答案是"abc",长度是3;给定"bbbbb"的答案是"b",长度为1。 【方式一】 粗暴的方法,找出字符串中所有长度的子串,逐一遍历并找出其中没有重复字符的字符串,...
  • 给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。 示例 1: 输入: "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。 示例 2: 输入: "bbbbb" 输出: 1 解释: 因为无...
  • 题目:给定一个字符串,请你找出其中不含有重复字符的最长子串的长度。 一开始我的想法是用list集合做,结果虽然很省空间但是用时过长 后来看了大佬们的解析以后才发现自己好傻..... 这是改进后的代码: ...
  • 给定一个字符串,请你找出其中不含有重复字符的最长子串的长度。示例1:输入: "abcabcbb"输出: 3解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。示例 2:输入: "bbbbb"输出: 1解释: 因为无重复字符的最长...
  • * 给定一个字符串,请你找出其中不含有重复字符串的最长子串的长度, * 新增一个附加条件:并输出相应的最长子串字符 */ #include <unordered_set> void testMaxChar() { //"abcabcbb" //char *src=...
  • 给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。 示例 1: 输入: s = “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”,所以其长度为 3。 示例 2: 输入: s = “bbbbb” 输出: 1 ...
  • 给定一个字符串 s ,请你找出其中不含有重复字符的 最长子串 的长度 示例 1: 输入: s = "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。 示例 2: 输入: s = "bbbbb" 输出: 1 解释: ...
  • 思路:首先就看一下这个问题的状态空间是怎么样的,这个问题的目标是找到最长的那个子串的长度,那么最终的状态变化就是长度这个数值,而决定着长度的维度变量有2个下标,一个start一个end分别代表当前所见的字符串...
  • 最长对称子串

    2021-04-16 15:06:07
    给定一个字符串(数字或大小写字母), 找出最长的对称的子串(如有多个,输出任意一个)。 例如: 输入:“abbaad” 输出:“abba” 输入描述: 字符串 输出描述: 字符串 示例1: 输入 a1223a 输出 22 ...
  • 有关查找字符串中最长重复子串 1.List的contains(obj)方法 实际上,List调用contains(Object obj)方法时,会遍历List中的每一个元素,然后再调用每个元素的equals()方法去跟contains()方法中的参数进行比较,如果...
  • 给定一个字符串,请你找出其中不含有重复字符的最长子串的长度。示例1:输入: "abcabcbb"输出: 3解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。示例 2:输入: "bbbbb"输出: 1解释: 因为无重复字符的最长...
  • #字符串中出现的第一个最长重复子串 class commonsubstring(): def maxlen(self,s1,s2): #最长公共子串的长度 for i in range(min(len(s1),len(s2))): if s1[i]==s2[i]: i+=1 else: break return i def ...
  • //给定一个字符串,找出其中的最长重复子串 public class LongestSubstring { public int longestSubSubstring(String s){ //设计思路:滑动窗口+指针。 滑动窗口保存不重复子串,指针依次向后移动。 int longest...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,221
精华内容 12,488
关键字:

最长重复子串问题