题目描述1
笔者解答1.1
class Solution {
public boolean PredictTheWinner(int[] nums) {
return total(nums,0,nums.length-1,1)>=0;
}
public int total(int[] nums,int start,int end,int turn){
if(start==end)
return nums[start]*turn;
int num=nums[start]*turn+total(nums,start+1,end,0-turn);
int num2=nums[end]*turn+total(nums,start,end-1,0-turn);
return Math.max(num*turn,num2*turn)*turn;
}
}
笔者分析1.2
因为写的十栈里面的题目，所以刚开始在想用栈来写的时候，是真的一点思路没有。琢磨着各种可以取到高分的情况，发现那是一环扣着一环，每次决定都受之后分数序列的影响，既然如此，便想到用递归来写（呸，看题解的）。说实话，递归这东西是真的巧妙啊，你不用去讨论如何才能取最大，你只需要告诉计算机，我就是要去最大，然后它就莫名其妙给你解决了，真香。
题目描述2
笔者解答2.1
class Solution {
public int trap(int[] height) {
boolean getfirst_unzero=false;
int left=0;
int sum=0;
for(int i=0;i<height.length;i++){
if(getfirst_unzero){
int temp=height[i];
if(temp<height[i-1]){
}
else if(temp>height[i-1]&&i-1==left){
left=i;
}
else if(temp>height[i-1]&&i-1!=left){
int temp_i=0;
if(temp<height[left])
for(int j=i-1;j>=left;j--){
if(height[j]>=temp)
{
temp_i=j;
break;
}
}
else
temp_i=left;
int min=temp>height[temp_i]?height[temp_i]:temp;
for(int j=temp_i+1;j<i;j++){
sum+=(min-height[j]);
height[j]=min;
}
if(temp>=height[left])
left=i;
}
}
if(!getfirst_unzero&&height[i]!=0){
left=i;
getfirst_unzero=true;
}
}
return sum;
}
}
笔者分析2.2
虽然代码长了点，但执行时间击败了百分之百的用户，而且也没有用什么数据结构，只是用了不同的思维去解这道题，就很有意思的 一道题。
题目描述3
笔者解答3.1
class Solution {
public int calculate(String s) {
Stack<Integer> stack = new Stack<Integer>();
int sign = 1, res = 0;
int length = s.length();
for (int i = 0; i < length; i++) {
char ch = s.charAt(i);
if (Character.isDigit(ch)) {
int cur = ch - '0';
while (i + 1 < length && Character.isDigit(s.charAt(i + 1)))
cur = cur * 10 + s.charAt(++i) - '0';
res = res + sign * cur;
} else if (ch == '+') {
sign = 1;
} else if (ch == '-') {
sign = -1;
} else if (ch == '(') {
stack.push(res);
res = 0;
stack.push(sign);
sign = 1;
} else if (ch == ')') {
res = stack.pop() * res + stack.pop();
}
}
return res;
}
}
笔者分析3.2
这种类型算是栈里比较典型的题目了。需要注意的是整数并不只是个位的。
题目描述4
笔者分析4.1
好吧，我是废物，我没写出来，虽然最后想到了递归，但。。。！
看了题解中的方法，题目要求最终返回的字符串必须包含所有出现过的字母，同时得让字符串的字典序最小。因此最终返回的字符串，最左侧的字符是在能保证其他字符至少能出现一次情况下的最小字符。（尽管方法已经介绍完了，但我还是没想出来用递归怎么写）。
算法：每次递归中，在保证其他字符至少出现一次的情况下，确定最小左侧字符。之后再将未处理的后缀字符串继续递归。
public class Solution {
public String removeDuplicateLetters(String s) {
int[] cnt = new int[26];
int pos = 0;
for (int i = 0; i < s.length(); i++) cnt[s.charAt(i) - 'a']++;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) < s.charAt(pos)) pos = i;
if (--cnt[s.charAt(i) - 'a'] == 0) break;//这一步是真的强
}
return s.length() == 0 ? "" : s.charAt(pos) + removeDuplicateLetters(s.substring(pos + 1).replaceAll("" + s.charAt(pos), ""));
}
}
总结
好菜啊，每日十题打卡第五天，以下图为证。
