Given a positive 32-bit integer n, you need to find the smallest 32-bit integer which has exactly the same digits existing in the integer n and is greater in value than n. If no such positive 32-bit integer exists, you need to return -1.

* Method 1: Math

1. Find the position to swap: traversal from right to left, find the first index whose value is smaller than its right index value. If no such index, return -1, which means current value is the maximum value can be represented by current numbers.

2. Swap the number in that index with the first number bigger than current one, traversal from right to the left.

3. Sort the values at right side of that index in ascending order.

classSolution {

publicintnextGreaterElement(intn) {

String s= n+"";

char[] arr= s.toCharArray();

int len= s.length(), i= len-2;

for(; i>=0; i--){

if(arr[i]< arr[i+1])break;

}

if(i<0)return-1;

for(int j= len-1; j> i; j--){

if(arr[j]> arr[i]){

char temp= arr[i];

arr[i]= arr[j];

arr[j]= temp;

break;

}

}

char[] sub=Arrays.copyOfRange(arr, i+1, len);

Arrays.sort(sub);

for(int j= i+1; j< len; j++){

arr[j]= sub[j- i-1];

}

long res=Long.parseLong(newString(arr));

return res>Integer.MAX_VALUE?-1: (int)res;

}

}

```

return result;

}

}

```

###AmazonSession

```Java

classSolution {

publicint[]exclusiveTime(intn,List<String>logs) {

int[] res=newint[n];

int currentTime=0;

Stack<Integer> stack=newStack<>();

for(String log: logs){

String[] tokens= log.split(":");

int id=Integer.parseInt(tokens[0]);

int time=Integer.parseInt(tokens[2]);

if(tokens[1].equals("start")){

if(!stack.isEmpty()){//current is begin, we need to update the previous id.

int preId= stack.peek();

res[preId]+= time- currentTime-1;

}

stack.push(id);

}else{

int preId= stack.pop();

res[preId]+= time- currentTime+1;

}

currentTime= time;

}

return res;

}

}

```

}

}

}

```

```

###AmazonSession

*Method1: dfs

```Java

classSolution {

privateSet<Integer> set;

privateint target;

publicbooleanfindTarget(TreeNoderoot,intk) {

if(root==null)returnfalse;

this.set=newHashSet<>();

this.target= k;

return dfs(root);

}

privatebooleandfs(TreeNodenode){

if(node==null)returnfalse;

if(set.contains(this.target- node.val))returntrue;

set.add(node.val);

return dfs(node.left)|| dfs(node.right);

}

}

```