目錄
30. 串聯所有單詞的子串——使用map解決子串包含單詞的順序問題
這道題，首先會想到先求出可以匹配的字符串（排列組合），再找出其在原字符串的位置。
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
int n=words.length;
if(n==0){
return new ArrayList<Integer>();
}
List<String> list =new ArrayList<String>();
String str="";
boolean[] visited=new boolean[n];
fun(list,words,n,0,str,visited);
List<Integer> re=new ArrayList<Integer>();
for(int i=0;i<list.size();i++){
int j=s.indexOf(list.get(i));
while(j!=-1){
if(!re.contains(j)){
re.add(j);
}
j=s.indexOf(list.get(i),j+1);
}
}
return re;
}
private void fun(List<String> list,String[] words,int n,int path,String s,boolean[] visited){
if(path==n){
list.add(s);
return;
}
for(int i=0;i<n;i++){
if(!visited[i]){
boolean[] newVisited = new boolean[n];
System.arraycopy(visited, 0, newVisited, 0, n);
newVisited[i] = true;
fun(list,words,n,path+1,s+words[i]+"",newVisited);
}
}
}
}
結果悲催的事情發生了！！！超時
這可怎麼辦呢？？？
採用滑動窗口、
如上圖，利用循環變量 i ，依次後移，判斷每個子串是否符合即可。
怎麼判斷子串是否符合？這也是這個題的難點了，由於子串包含的單詞順序並不需要固定，如果是兩個單詞 A，B，我們只需要判斷子串是否是 AB 或者 BA 即可。如果是三個單詞 A，B，C 也還好，只需要判斷子串是否是 ABC，或者 ACB，BAC，BCA，CAB，CBA 就可以了，但如果更多單詞呢？那就崩潰了。
用兩個 HashMap 來解決。首先，我們把所有的單詞存到 HashMap 裏，key 直接存單詞，value 存單詞出現的個數（因爲給出的單詞可能會有重複的，所以可能是 1 或 2 或者其他）。然後掃描子串的單詞，如果當前掃描的單詞在之前的 HashMap 中，就把該單詞存到新的 HashMap 中，並判斷新的 HashMap 中該單詞的 value 是不是大於之前的 HashMap 該單詞的 value ，如果大了，就代表該子串不是我們要找的，接着判斷下一個子串就可以了。如果不大於，那麼我們接着判斷下一個單詞的情況。子串掃描結束，如果子串的全部單詞都符合，那麼該子串就是我們找的其中一個。看下具體的例子。
看下圖，我們把 words 存到一個 HashMap 中。
第一個單詞在 HashMap1 中，然後我們把 foo 存到 HashMap2 中。並且比較此時 foo 的 value 和 HashMap1 中 foo 的 value，1 < 2，所以我們繼續掃描。
第三個單詞也在 HashMap1 中，然後把 foo 存到 HashMap2 中，因爲之前已經存過了，所以更新它的 value 爲 3，然後繼續比較此時 foo 的 value 和 HashMap1 中 foo 的 value，3 > 2，所以表明該字符串不符合。然後判斷下個子串就好了。
當然上邊的情況都是單詞在 HashMap1 中，如果不在的話就更好說了，不在就表明當前子串肯定不符合了，直接判斷下個子串就好了。
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
List<Integer> res = new ArrayList<Integer>();
int wordNum = words.length;
if (wordNum == 0) {
return res;
}
int wordLen = words[0].length();
//HashMap1 存所有單詞
HashMap<String, Integer> allWords = new HashMap<String, Integer>();
for (String w : words) {
int value = allWords.getOrDefault(w, 0);
allWords.put(w, value + 1);
}
//遍歷所有子串
for (int i = 0; i < s.length() - wordNum * wordLen + 1; i++) {
//HashMap2 存當前掃描的字符串含有的單詞
HashMap<String, Integer> hasWords = new HashMap<String, Integer>();
int num = 0;
//判斷該子串是否符合
while (num < wordNum) {
String word = s.substring(i + num * wordLen, i + (num + 1) * wordLen);
//判斷該單詞在 HashMap1 中
if (allWords.containsKey(word)) {
int value = hasWords.getOrDefault(word, 0);
hasWords.put(word, value + 1);
//判斷當前單詞的 value 和 HashMap1 中該單詞的 value
if (hasWords.get(word) > allWords.get(word)) {
break;
}
} else {
break;
}
num++;
}
//判斷是不是所有的單詞都符合條件
if (num == wordNum) {
res.add(i);
}
}
return res;
}
}
時間複雜度：假設 s 的長度是 n，words 裏有 m 個單詞，那麼時間複雜度就是 O（n * m）。
空間複雜度：兩個 HashMap，假設 words 裏有 m 個單詞，就是 O（m）。
](https://img-blog.csdnimg.cn/20200213105921644.png)
慢的可憐！！！！
怎麼優化呢？？
- 情況一：當子串完全匹配，移動到下一個子串的時候。
![]()
在解法一中，對於 i = 3 的子串，我們肯定是從第一個 foo 開始判斷。但其實前兩個 foo 都不用判斷了 ，因爲在判斷上一個 i = 0 的子串的時候我們已經判斷過了。所以解法一中的 HashMap2 每次並不需要清空從 0 開始，而是可以只移除之前 i = 0 子串的第一個單詞 bar 即可，然後直接從箭頭所指的 foo 開始就可以了。 - 情況二：當判斷過程中，出現不符合的單詞。
![]()
但判斷 i = 0 的子串的時候，出現了 the ，並不在所給的單詞中。所以此時 i = 3，i = 6 的子串，我們其實並不需要判斷了。我們直接判斷 i = 9 的情況就可以了。 - 情況三：判斷過程中，出現的是符合的單詞，但是次數超了。
![]()
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
List<Integer> res = new ArrayList<Integer>();
int wordNum = words.length;
if (wordNum == 0) {
return res;
}
int wordLen = words[0].length();
HashMap<String, Integer> map1 = new HashMap<String, Integer>();
//map1賦予值
for (String w : words) {
int value = map1.getOrDefault(w, 0);
map1.put(w, value + 1);
}
int gasLen=0;//移動的距離
for(int i=0;i<s.length()-wordNum*wordLen+1;i++){
HashMap<String, Integer> map2 = new HashMap<String, Integer>();
int num = 0;
while(num<wordNum){
String word = s.substring(i + num * wordLen, i + (num + 1) * wordLen);
if(map1.containsKey(word)){
int value=map2.getOrDefault(word,0);
map2.put(word,value+1);
if(map2.get(word)>map1.get(word)){
break;
}
}
else{
break;
}
num++;
}
if (num == wordNum) {
res.add(i);
}
}
return res;
}
}
總
這道題最大的亮點就是應用了 HashMap 了吧，使得我們不再糾結於子串包含單詞的順序。然後對於算法的優化上，還是老思路，去分析哪些判斷是不必要的，然後把它除之。
31. 下一個排列——技巧
class Solution {
public void nextPermutation(int[] nums) {
//判斷是否是最大值（全部是降序排列）
if(nums.length==1){
return ;
}
int i=1;
boolean flag=true;
for(;i<nums.length;i++){
if(nums[i]>nums[i-1]){
flag=false;
}
}
if(flag)
{
int p=0;
int q=nums.length-1;
while(p<q){
int temp=nums[p];
nums[p]=nums[q];
nums[q]=temp;
p++;
q--;
}
return ;
}
//從後到前找到最大降序序列 j到n-1
//將j-1置位j到n-1的比它大的最小值，並且將後面的j到n-1降序排列
int j=nums.length-1;
for(;j>0;j--){
if(nums[j]>nums[j-1]){
break;
}
}
//j=2;
int k=nums[j-1];//存放
//j-1置位j到n-1的比它大的最小值
int pos=-1;
int min=Integer.MAX_VALUE;
for(int m=j;m<nums.length;m++){
if(nums[m]>k&&nums[m]<min){
min=nums[m];
pos=m;
}
}
nums[j-1]=min;
nums[pos]=k;
//將後面的數升序排列
Arrays.sort(nums, j, nums.length);
}
}
32. 最長有效括號——動態規劃
這道題會想到動態規劃
爲什麼會想到動態規劃呢？？
首先明確一點動態規劃解決的是 有很多解求最優解的問題
而本題中 求最長有效括號。
有效括號 有很多我們求的是最長的那個，即爲最優解。
首先定義動態規劃的數組代表什麼
dp [ i ] 代表以下標 i 結尾的合法序列的最長長度，例如下圖
下標 1 結尾的最長合法字符串長度是 2，下標 3 結尾的最長字符串是 str [ 0 , 3 ]，長度是 4 。
我們來分析下 dp 的規律。
首先我們初始化所有的 dp 都等於零。
以左括號結尾的字符串一定是非法序列，所以 dp 是零，不用更改。
以右括號結尾的字符串分兩種情況。
- 右括號前邊是 ( ，類似於 ……（）。
dp [ i ] = dp [ i - 2] + 2 （前一個合法序列的長度，加上當前新增的長度 2）
類似於上圖中 index = 3 的時候的情況。
dp [ 3 ] = dp [ 3 - 2 ] + 2 = dp [ 1 ] + 2 = 2 + 2 = 4
- 右括號前邊是 )，類似於 ……））。
此時我們需要判斷 i - dp[i - 1] - 1 （前一個合法序列的前邊一個位置） 是不是左括號。
例如上圖的 index = 7 的時候，此時 index - 1 也是右括號，我們需要知道 i - dp[i - 1] - 1 = 7 - dp [ 6 ] - 1 = 4 位置的括號的情況。
而剛好 index = 4 的位置是左括號，此時 dp [ i ] = dp [ i - 1 ] + dp [ i - dp [ i - 1] - 2 ] + 2 （當前位置的前一個合法序列的長度，加上匹配的左括號前邊的合法序列的長度，加上新增的長度 2），也就是 dp [ 7 ] = dp [ 7 - 1 ] + dp [ 7 - dp [ 7 - 1] - 2 ] + 2 = dp [ 6 ] + dp [7 - 2 - 2] + 2 = 2 + 4 + 2 = 8。
如果 index = 4 不是左括號，那麼此時位置 7 的右括號沒有匹配的左括號，所以 dp [ 7 ] = 0 ，不需要更新。
上邊的分析可以結合圖看一下，可以更好的理解，下邊看下代碼。
class Solution {
public int longestValidParentheses(String s) {
int maxans = 0;
int dp[] = new int[s.length()];
for (int i = 1; i < s.length(); i++) {
if (s.charAt(i) == ')') {
//右括號前邊是左括號
if (s.charAt(i - 1) == '(') {
dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
//右括號前邊是右括號，並且除去前邊的合法序列的前邊是左括號
} else if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
}
maxans = Math.max(maxans, dp[i]);
}
}
return maxans;
}
}
33. 搜索旋轉排序數組
class Solution {
public int search(int[] nums, int target) {
int len = nums.length;
int left = 0, right = len-1;
while(left <= right){
int mid = (left + right) / 2;
if(nums[mid] == target)
return mid;
else if(nums[mid] < nums[right]){
if(nums[mid] < target && target <= nums[right])
left = mid+1;
else
right = mid-1;
}
else{
if(nums[left] <= target && target < nums[mid])
right = mid-1;
else
left = mid+1;
}
}
return -1;
}
}
34. 在排序數組中查找元素的第一個和最後一個位置
class Solution {
public int[] searchRange(int[] nums, int target) {
int n=nums.length;
if(n==0){
return new int[]{-1,-1};
}
int low=0;
int high=n-1;
int first=-1,last=-1;
while(low<=high){
int mid=(low+high)/2;
if(nums[mid]==target){
first=mid;
last=mid;
while(first>=0&&nums[first]==target){
first--;
}
while(last<=n-1&& nums[last]==target){
last++;
}
first++;
last--;
break;
}
else if(nums[mid]>target){
high=mid-1;
}
else{
low=mid+1;
}
}
return new int[]{first,last};
}
}
35. 搜索插入位置
class Solution {
public int searchInsert(int[] nums, int target) {
int n=nums.length;
if(n==0){
return 0;
}
int low=0;
int high=n-1;
int first=-1,last=-1;
while(low<=high){
int mid=(low+high)/2;
if(nums[mid]==target){
return mid;
}
else if(nums[mid]<target){
low=mid+1;
}
else{
high=mid-1;
}
}
return low;
}
}
36. 有效的數獨——hashset or 位圖
方法一：使用hashset
public class Solution {
public boolean isValidSudoku(char[][] board) {
Set<String> seen = new HashSet<>();
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
char number = board[i][j];
if (number != '.')
if (!seen.add(number + " in row " + i)
|| !seen.add(number + " in column " + j)
|| !seen.add(number + " in block " + i / 3 + "-"+ j / 3))
return false;
}
}
return true;
}
}
方法二：使用位圖（快）
class Solution {
public boolean isValidSudoku(char[][] board) {
int[] map = new int[9];
for(int y=0; y<9; y++){
for(int x=0; x<9; x++){
int key = board[y][x] - '1'; //key:數字
if(key >= 0 && key <= 8) { //1~9有效數字
int index = (1<<x) //Value:位置編碼，最低9位存放列號
| (1<<(y+9)) //中間9位存放行號
| (1<<(x/3 + y/3*3 + 18)); // z爲9宮格區域序號
int old = map[key];
if((old & index) == 0) //無重複，則按位或，加入位置集合
map[key] = old | index;
else //有重複
return false;
}
}
}
return true;
}
}
37. 解數獨——回溯（注意：這裏是求得一個解就返回 dfs返回值應該爲 boolean型）
class Solution {
public void solveSudoku(char[][] board) {
int[] map = new int[9];
//初始化map
init(board,map);
int cur=blockNum(board);
dfs(cur,board,map);
return ;
}
public boolean dfs(int cur,char[][] board, int[] map){
if(cur==0){
return true ;//表示填完了
}
int x = 0, y = 0;
//記爲x y
boolean flag=false;
for(int i = 0; i < 9; i++){
for(int j = 0; j < 9; j++){
if(board[i][j] == '.'){
x = i;
y = j;
flag=true;
break;
}
}
if(flag){
break;
}
}
//遍歷當前的可選數字
int index = (1<<y) //Value:位置編碼，最低9位存放列號
| (1<<(x+9)) //中間9位存放行號
| (1<<(y/3 + x/3*3 + 18)); // z爲9宮格區域序號
for(int i=0;i<9;i++){
int old=map[i];
if((old & index)==0){
//無重複，表示可以放在i+1這個數，則按位或
board[x][y]=(char)('1' + i);
map[i]=old | index;
if(dfs(cur-1, board,map))
{return true;}
//恢復現場
map[i]=old;
board[x][y]='.';
}
}
return false;
}
public int blockNum(char[][] board){
int cur=0;
for(int i=0;i<9;i++){
for(int j=0;j<9;j++){
if(board[i][j]=='.'){
cur++;
}
}
}
return cur;
}
public void init(char[][] board ,int[] map) {
for(int x=0; x<9; x++){
for(int y=0; y<9; y++){
int key = board[x][y] - '1'; //key:數字
if(key >= 0 && key <= 8) { //1~9有效數字
int index = (1<<y) //Value:位置編碼，最低9位存放列號
| (1<<(x+9)) //中間9位存放行號
| (1<<(y/3 + x/3*3 + 18)); // z爲9宮格區域序號
int old = map[key];
map[key] = old | index;
}
}
}
return ;
}
}
38. 外觀數列
class Solution {
public String countAndSay(int n) {
if(n==0)
return "";
if(n==1){
return "1";
}
String re="1";
String s="";
for(int i=1;i<n;i++){
for(int j=0;j<re.length();j++){
int k=1;
while(j+k<re.length()&&re.charAt(j)==re.charAt(j+k)){
k++;
}
s+=(k+""+re.charAt(j)+"");
j=j+k-1;
}
re=s;
s="";
}
return re;
}
}
39.組合總和
class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> list=new ArrayList<List<Integer>>();
List<Integer> l=new ArrayList<Integer>();
int sum=0;
Arrays.sort(candidates);
dfs(list,l,target,sum,candidates);
return list;
}
private void dfs(List<List<Integer>> list,List<Integer> l,int target,int sum,int[] candidates){
if(sum==target){
list.add(l);
}
for(int i=0;i<candidates.length;i++){
if(sum+candidates[i]>target){
break;
}
if(l.size()>0&&l.get(l.size()-1)>candidates[i]){
continue;
}
List<Integer> newL =new ArrayList<Integer>(l);
newL.add(candidates[i]);
dfs(list,newL,target,sum+candidates[i],candidates);
}
}
}
40.組合總和 II
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
List<List<Integer>> list=new ArrayList<List<Integer>>();
List<Integer> l=new ArrayList<Integer>();
int sum=0;
boolean[] used=new boolean[candidates.length];
Arrays.sort(candidates);
dfs(list,l,target,sum,candidates,used);
return list;
}
private void dfs(List<List<Integer>> list,List<Integer> l,int target,int sum,int[] candidates,boolean[] used){
if(sum==target){
list.add(l);
}
for(int i=0;i<candidates.length;i++){
if(sum+candidates[i]>target){
break;
}
if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
continue;
}
if(l.size()>0&&l.get(l.size()-1)>candidates[i]){
continue;
}
if(!used[i]){
List<Integer> newL =new ArrayList<Integer>(l);
newL.add(candidates[i]);
boolean[] newUsed = new boolean[used.length];
System.arraycopy(used, 0, newUsed, 0,used.length);
newUsed[i] = true;
dfs(list,newL,target,sum+candidates[i],candidates, newUsed);
}
}
}
}
