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/