左神算法笔记（二十四）——扩展题目

题目一

思路

整体思路是形成一个双端队列，利用双端队列如果当前队列中的数值小于等于当前值，就向右方扩展，如果大于则将左边的数值去掉。
之所以可以采用双指针在于数组中的数据全部都是正数，则指针增加则会增加，左指针增加则数据减少

代码

public static int getMaxLength(int[] arr,int k){
	if(arr == null || arr.length == null || k<0){
		return 0;
	}
	int L = 0;
	int R = 0;
	int sum = arr[0];
	int len = 0;
	while(R < arr.length){
		if(sum == k){
			len = Math.max(len,R-L+1);
			sum -= arr[L++];
		}else if(sum < k){
			R ++;
			if(R == arr.length){
				break;
			}
			sum += arr[R];
		}else{
			sum -= arr[L++];
		}
	}
	return len;
}
	

题目二

思路

新建两个数组，第一个数组保存当前位置往右开始求得的最小的累加和的值，第二个数组保存求到当前最小累加和的时候最后的位置。如果右面的累加和是负数，则证明有利可图，可以减少当前值，则当前值加上右方的最小累加和，并且将右方保存的最后位置赋值到当前位置，从而可以快速求出最小累加和。
此时求解当前位置的最小累加和的时候就可以利用刚才形成的两个数组进行求解，对于是否包含当前位置会直接包含当前的最小累加和，并且此时的位置会直接指到求出最小累加和最右方的位置，并且再次向后方进行计算。如果当前累加和符合，但是加上新的元素不行时，则此时按照双端队列的形式将最左边的元素去掉看能否将新的元素加入。

代码

public static int maxLengthAwesome(int[] arr,int k){
	if(arr ==null || arr.length == 0){
		return 0;
	}
	int [] sums = new int[arr.length];
	//现在采用的是哈希表，其实可以用数组
	HashMap<Integer,Integer> ends = new HashMap<Integer,Integer>();
	sums[arr.length -1] = arr[arr.length -1];
	ends.put(arr.length-1,arr.length-1);
	//从右向左算，如果右方值大于0，则此时无利可图，所以保存当前值和当前的位置
	//如果此时右方的值小于0，则此时将当前位置和右方的最小和求和便是当前位置上的最小和，返回当前和和之前的最小和到的最右位置
	for(int i = arr.length-2;i>=0;i++){
		if(sums[i+1]<0){
			sums[i] = arr[i]+sums[i+1];
			ends.put(i,ends.get(i+1));
		}else{
			sums[i] = arr[i];
			ends.put(i,i);
		}
	}
	int end = 0;
	int sum = 0;
	int res = 0;
	for(int i = 0;i <arr.length;i++){
		//当前位置求和跟k进行比较，如果此时求和的值小于等于k则一直累加
		while(end<arr.length && sum+sums[end] <= k){
			sum +=sums[end];
			end = ends.get(end)+1;
		}
		//如果此时再加下一个就超了，则开始执行下面的操作
		//判断end跟i的关系，如果此时i还没到则sum-0，如果当前位置等于end，则此时sum减去当前位置
		sum -=end >i ?arr[i] :0;
		res = Math.max(res,end -i);
		end = Math.max(end,i+1);
	}
	return res;
}

左神之前的代码可以看左神的书或者进阶班第六章第五题的下方代码

题目三

这个单链表可以转化成数学问题，在纸上画出象限，将数字跟编号的关系进行记录，找到最后剩下的人和最原始的编号之间的关系。旧 = （新-1+s）%i+1。

代码

传统算法：

public static Node jsfKill1(Node head,int m){
	if(head == null || head.next == head || m<1){
		return head;
	}
	Node last = head;
	while(last.next != head){
		last = last.next;
	}
	int count = 0;
	while(head != last){
		if(++count == m){
			last.next = head.next;
			count = 0;
		}else{
			last = last.next;
		}
		head = last.next;
	}
	return head;
}

利用数学规律的算法：

public static Node jsfKill2(Node head,int m){
	if(head == null || head.next == head ||m<1){
		return head;
	}
	Node cur = head.next;
	int tmp = 1;
	while(cur != head){
		tmp++;
		cur = cur.next;
	}
	tmp = getLive(tmp,m);
	while(--tmp != 0){
		head = head.next;
	}
	head.next = head;
	return head;
}

public static int getLive(int i,int m){
	if(i ==1){
		return 1;
	}
	return (getLive(i-1,m)+m-1)%i+1;
}

题目四

思路

对于本题，将字符从末尾开始匹配，设定一个函数f（i，j）其中i表示str中的i位置，j表示exp中的j位置。如果从最后发现无法匹配，则直接返回false，如果从末尾开始可以匹配，再依次向前推，看j之后位置是否包含特殊的字符（）如果包含，则表示可以延长任意多个j位置上的字符，然后进行i-1和j位置进行判断，直到不符合时为止。
除此之外如果出现.，则认为和任意字符都可以匹配，不管字符内容，此时直接跳转到前一个位置f（i-1，j-1）。其他的普通字符就直接进行比较，如果出现*，则直接让j变成j的上一个位置j-1.
从后向前可能存在一种bug，如果出现.这种情况,则此时从后向前进行判断时，会出现问题因为会在其中持续进行循环，无法进行到j之前的位置，最后导致无法进行判断。所以如果修改的话需要进行一个遍历，经历每一个路，只要有一个返回true则为true。
此时从前向后就可以解决这个问题，并且思路和从后向前一样，如果exp中出现任意字符，则进行下个字符的判断，出现和不出现*都进行对应的判断，从而解决问题。

代码

public static boolean process(char[] str,char[] exp,int i,int j){
	if(j == exp.length){
		return i = str.length;
	}
	//j到结尾或者j+1后面不是*，则为正常情况，i = str.length的话表示str数组提前结束了。
	if(j+1 == exp.length || exp[j+1] != "*"){
		return i != str.length && (exp[j] == str[i] || exp[j] == ".") && process(str,exp,i+1,j+1);
	}
	//exp的j+1位置不仅有字符，而且字符为“*”，当前while执行的前提是上面的if不执行，意味着或者到了最后或者为*，此时while中又进行了最后位置的判断
	//第一个while发生时，发现后序可以走通，则返回true，如果第一个if不返回true，则继续进行尝试。
	while(i != str.length && (exp[j] == str[i] || exp[j] == '.')){
		if(process(str,exp,i,j+2)){
			return true;
		}
		i++;
	}
	return process(str,exp,i,j+2);
}

改动态规划

因为共有两个变量，所以二维表。坐标分别为i（0，str.length）和j（0，exp.length）。
1. 不变的参量为当i和j都耗尽，此时求的是最后的结果
2. 最终的目标是（0，0）状态
3. 中间的依赖情况可以看到当前位置依赖于右下角（i+1,j+1)位置或者直接i的后两列的位置。如果可以将最后两列和最后一排搞定，

当推完位置依赖的时候需要观察之前的basecase是否找全，根据位置依赖的位置来反过来确定basecase。在这个题中，在if中判断的情况也是basecase。

public static boolean isMatchDP(String str,String exp){
	if(str == null || exp == null){
		return false;
	}
	char[] s = str.toCharArray();
	char[] e = exp.toCharArray();
	if(!isValid(s,e)){
		return false;
	}
	boolean[][] dp = initDPMap(s,e);
	for(int i = s.length-1;i>-1;i--){
		for(int j = e.length-2;j>-1;j--){
			if(e[j+1] != '*'){
				dp[i][j] = (s[i] == e[j] ||e[j] == '.')&&dp[i+1][j+1];
			}else{
				int si = i;
				while(si != s.length && (s[si] == e[j] || e[j] == '.')){
					if(dp[si][j+2]){
						dp[i][j] = true;
						break;
					}
					si++;
				}
				if(dp[i][j] != true){
					dp[i][j] = dp[si][j+2];
				}
			}
		}
	}
	return dp[0][0];
}

//进行初始化边缘的map值
public static boolean[][] initDPMap(charp[] s,char[] e){
	int slen = s.length;
	int elen = e.length;
	boolean[][] dp = new boolean[slen+1][elen+1];
	dp[slen][elen] = true;
	for(int j = elen-2;j>-1;j = j-2){
		if(e[j] != '*' && e[j+1] =='*'){
			dp[slen][j] = true;
		}else{
			break;
		}
	}
	if(slen >0 && elen >0){
		if((e[elen-1] =='.' || s[slen-1] ==e[elen-1])){
			dp[slen-1][elen-1] = true;
		}
	}
	return dp;
}