Leetcode Lect1 String相关题目

Java 的 String 类基本用法介绍：http://www.runoob.com/java/java-string.html

Java 的 String.substring 函数：https://beginnersbook.com/2013/12/java-string-substring-method-example/

Google coding style：https://google.github.io/styleguide/javaguide.html

String 不支持下标索引的方式访问，所以需要使用charAt(i)的方式访问对应位置的字符。同时也就没有办法使用下标的方式对String进行修改。

String是一种不可变类，字符串一但生成就不能被改变。例如我们使用**‘+’进行字符串连接，会产生新的字符串，原串不会发生任何变化；使用replace()** 进行替换某些字符的时候也是产生新的字符串，不会更改原有字符串。

https://leetcode.com/problems/valid-palindrome/submissions/

class Solution {
    public boolean isValid(char c){
        return (Character.isLetter(c) || Character.isDigit(c));
    }
    
    public boolean isPalindrome(String Ss) {
        String s=Ss.toLowerCase();
        int sl=s.length();
        int xl=0, xr=sl-1;
        boolean res=true;
        while(xl<xr){
            while(xl<sl && (!isValid(s.charAt(xl))))     xl+=1;
            while(xr>=0 && (!isValid(s.charAt(xr))))     xr-=1;
            if(xr<0 || xl>=sl)
                break;
            if(s.charAt(xl)!=s.charAt(xr)){
                res=false;
                break;
            }
            xl+=1;
            xr-=1;
        }
        return(res);
    }
}

Rabin-Karp Algorithm：在字符串中找子串

算法原理：

Ref: https://www.jianshu.com/p/68cbe955103e

https://leetcode.com/problems/implement-strstr/

class Solution {
    public int MOD=1000000;
    public int INC=31;
    public int strStr(String src, String dsc) {
        if(src==null || dsc==null)
            return -1;
        int dl=dsc.length(), sl=src.length();
        if(dl==0)
            return 0;
        
        int power=1;
        for(int i=0;i<dl;i++)
            power=(power*INC)%MOD;
        
        int dschash=0;
        for(int i=0;i<dl;i++)
            dschash = (dschash*INC + dsc.charAt(i)) % MOD;      //hash code of dsc
        
        int srchash=0;
        for(int i=0;i<sl;i++){
            srchash = (srchash*INC + src.charAt(i)) % MOD;      //calculate hash of src
            if(i<dl-1)
                continue;
            else if(i>=dl){
                srchash = srchash - (src.charAt(i-dl) * power) % MOD;
                while(srchash<0)
                    srchash += MOD;
            }
            if(srchash == dschash){         //hash(src[i-m+1..i]) == hash(dsc)
                if(src.substring(i-dl+1, i+1).equals(dsc))
                    return(i-dl+1);
            }
        }
        
        return(-1);
    }
}

子数组与前缀和

https://leetcode.com/problems/maximum-subarray/

使用前缀和，令p[i]=sum{ A[0]...A[i-1] }（p[0]=0，这个是为了方便后面计算用），那么就有sum{A[i]...A[j]} = p[j+1]-p[i]

设f[j]表示所有以A[j]结尾的子数组中最大的subarray，那么就有f[j] = p[j+1] - min{ p[0]...p[j] }

单纯的计算某个f[j]的时间复杂度是O(N)的，但其实计算好f[j]后，可以用O(1)的时间再计算出f[j+1]。所以整体的时间复杂度仍然是O(N)的。

class Solution {
    public int maxSubArray(int[] nums) {
        int nl=nums.length;
        int[] prefix=new int[nl+1];
        prefix[0]=0;
        for(int i=1;i<nl+1;i++)
            prefix[i]=prefix[i-1]+nums[i-1];
        
        int[] f=new int[nl];
        int minp=0;
        
        for(int i=0;i<nl;i++){
            minp=Math.min(minp, prefix[i]);
            f[i]=prefix[i+1]-minp;
        }
        
        int ans=f[0];
        for(int i=1;i<nl;i++)
            ans=Math.max(ans, f[i]);
        return(ans);        
    }
}

https://www.lintcode.com/problem/subarray-sum/description

Q：找和为0的subarray

A：求出prefix[]，用hashmap找里面相等的元素。O(N)

https://www.lintcode.com/problem/subarray-sum-closest/description

Q：找和最接近0的subarray

A：求出prefix[]，找prefix[]中最接近的两个元素（排序）。 O(NlogN)

其他

UNDER CONSTRUCTION

https://leetcode.com/problems/subsets/

https://leetcode.com/problems/subsets-ii/