# Algorithms Tips (4) – Basic Data Structure

Here we record some basic data structures which are easily involved in coding.

• PriorityQueue
Sometimes, we want to sort hashmap by its value, we can introduce PriorityQueue to override its compare function to reach the goal. (Laster, I will add more compare function to popular PriorityQueue’s field.)

``` Map<Integer, Integer> tweets = new HashMap();
PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>(){
@Override
public int compare(Integer a, Integer b) {
return tweets.get(b) - tweets.get(a);
// tweets.get(a)-tweets.get(b) is increasing/ascending
// tweets.get(b)-tweets.get(a) is downing trend
}
});
• Set
If we want to add unique value to the output, we can use set as an intermedium variable to help to check during adding process.

```Set set = new HashSet();
set.remove("a");
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
String elem = iterator.next();
}```
• TreeMap
A TreeMap provides an efficient means of sorting key/value pairs in sorted order and allows rapid retrieval. Its elements will be sorted in an ascending key order.

```TreeMap tm = new TreeMap();
tm.put("a", 2);
tm.put("b", 1);
tm.get("a"); // return 2
tm.lastKey(); // return "b"
tm.firstKey(); // return "a"
tm.remove("a");
TreeMap<Integer, HashSet> t = new TreeMap();
// if HashSet's size is zero, we need to use t.remove(key) to
remove this element in TreeMap. Because its null value will
influence TreeMap's firstKey and lastKey result.```
• List
```Arrays.asList("a", "b");// initialize List with values
// List to Array
lists.toArray(new String[lists.size()]);```

For recursion method, we might need to copy the last result to current result. For example, for f(i-1), its result is left (List<Integer>) and for f(i), its result is to merge left with current value.
Wrong version:

``` List<List<Integer>> rec = new ArrayList<List<Integer>>():
for(List<Integer> left: lefts) {
}```

Right version:

``` List<List<Integer>> rec = new ArrayList<List<Integer>>():
for(List<Integer> left: lefts) {
ArrayList<Integer> elem = new ArrayList<Integer>(left);
}```

The problem of the wrong version is that it will change left’s content. For example, if left=[[], [1]] and nums[1]=2, the wrong version’s output is [[2],[1,2],[2],[1,2]]. For the right version, it creates a new ArrayList to physically build a new list, so later add method won’t change original content. So the right output is [[], [1], [2], [1,2]].

• Stack
```Stack<String> s = new Stack();
s.push("zara");
s.peek();
s.pop();```
• String
```int integer = 1;
String t = String.valueOf(integer);```

The string is very common, so the only special point is to convert to char[] when needed.

• ``` char[] arr = str.toCharArray();
Arrays.sort(arr);
String t = String.valueOf(arr);
String t1 = new String(arr);```

# Algorithm Tips (3) – Building Suitable Data Structure

The more LeetCode questions we practice, the more rules we find. We can split all questions to serval categories, such as Stack, Map/HashMap, Dynamic Programming, etc. It looks good to use these existing data structure to improve the solution, but sometimes, we still need to build our own suitable data structure to fit some questions’ special scenario.

Today I take “Binary Tree Maximum Path Sum” as an example. (Later, I will enhance this post by adding more examples.)

### Question:

Given a binary tree, find the maximum path sum. For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.

### Analysis:

For any node, it has two cases, one is single side(not circle), the other is go-through-circle. We need to record the two cases for each node and then to be provided to parent’s node to evaluate. So it is quite clear to solve the problem. Now you can use int[] which contains 2 elements to code it, but we all know it is not the good one and hard to read. The better solution is to build our own data structure to describe the two cases clearly.

```private class ResultType {
int singlePath, maxPath;
ResultType(int singlePath, int maxPath) {
this.singlePath = singlePath;
this.maxPath = maxPath;
}
}```

Here we conclude above two cases to two parameters: singlePath is to record the maximum path for single side(not circle) and maxPath to record the maximum value for the current node, including circle case and non-circle case. So the whole codes are here:

```/**
* Definition for a binary tree node.
* public class TreeNode {
*   int val;
*   TreeNode left;
*   TreeNode right;
*   TreeNode(int x) { val = x; }
* }
*/
public class Solution {
private class ResultType {
int singlePath, maxPath;
ResultType(int singlePath, int maxPath) {
this.singlePath = singlePath;
this.maxPath = maxPath;
}
}
public int maxPathSum(TreeNode root) {
ResultType res = helper(root);
return res.maxPath;
}

public ResultType helper(TreeNode root) {
if (root == null)
return new ResultType(Integer.MIN_VALUE, Integer.MIN_VALUE);
ResultType left = helper(root.left);
ResultType right = helper(root.right);

int singlePath = Math.max(0,
Math.max(left.singlePath, right.singlePath)) + root.val;
int maxPath = Math.max(left.maxPath, right.maxPath);
maxPath = Math.max(maxPath,
Math.max(left.singlePath, 0)+
Math.max(right.singlePath, 0)+root.val);
return new ResultType(singlePath, maxPath);
}
}```

We see parent’s singlePath = Max(their children’s singlePath + root value) and parent’s maxPath = Max( children’s maxPath,  children’s singlePath + root value).

Meanwhile, we comparing singlePath with zero, to determine whether to involve it or not.

Another clever point is to return Integer.MIN_VALUE, not zero for the empty node. This is very clever to solve the case, like only one node with a negative value. Because in this case, this negative value is still the maximum value for this node.

# Algorithm Tips (2) – Avoiding Data Overflow

Today we talk about overflow. This is a very shy problem when interviewing. And it is also a very good way to distinguish whether you are a good programmer or just so-so programmer.

When I interviewed in a big company (I forgot its name, maybe eBay), the interviewer asked me to write a sum function. So easy?! In fact, No. You have to consider overflow for your solution.

## Concept of Overflow and Underflow

First, let’s understand what’s overflow and what’s underflow. Overflow and underflow are related to a data type. Every data type has its own range. For example, int, in Java, you can use Integer.MIN_VALUE and Integer.MAX_VALUE to know its range. In Java arithmetic operators, it doesn’t report overflow and underflow problem and never throws an error exception. It just simply swallows it.

• int operators:
When the value of an operation is larger than 32 bits, then the low 32 bits only taken into consideration and the high order bits are discarded. And when its most significant bit(MSB) is 1 then the value is treated as negative.
• floating point operators:
Overflow will result in Infinity and underflow will result as 0.0.

## Solutions to avoid overflow or underflow

Second, there are several ways to avoid it.

• using long to replace int
• using uint to replace int
• using double to apply intermediate variable
• use the mod method to avoid it, This is a very common solution in LeetCode, within the question, it already obviously reminds you to use mod 100000007 if the answer is very large.

## Examples

Finally, I list my solution for LeetCode-576 (Out of Boundary Paths) (Here I don’t list the content of the question, you can read it from LeetCode’s website. ) to help you understand how to avoid overflow issue. Meanwhile, it is a good way to see how to use three dimensions array to fix the problem with dynamic programming method.

```public class Solution {
public int findPaths(int m, int n, int N, int i, int j) {
final int MOD = 1000000007;
if (N == 0) return 0;
long[][][] dp = new long[m][n][N+1]; //k:1-N
for(int ii=0; ii<m;ii++) {
for(int jj=0; jj<n;jj++) {
int count = 0;
if (ii-1<0) count++;         if (ii+1>=m) count++;
if (jj-1<0) count++;         if (jj+1>=n) count++;
dp[ii][jj][1] = count;
}
}
for(int k=2; k<=N;k++) {
for(int ii=0; ii<m; ii++) {
for(int jj=0; jj<n; jj++) {
long count = 0;
if (ii-1>=0) count += dp[ii-1][jj][k-1];
if (jj-1>=0) count += dp[ii][jj-1][k-1];
if (ii+1<m) count += dp[ii+1][jj][k-1];
if (jj+1<n) count += dp[ii][jj+1][k-1];
dp[ii][jj][k] = count%MOD;
}
}
}
long rec = 0;
for(int k=1; k<=N; k++) {
rec += dp[i][j][k];
}
return (int)(rec%MOD);
}
}```

Another simple LeetCode question also requires us to consider overflow issue: Valid Binary Search Tree. Here is the solution which considers using Long to replace Integer to avoid overflow.

```/**
* Definition for a binary tree node.
* public class TreeNode {
*   int val;
*   TreeNode left;
*   TreeNode right;
*   TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public boolean isValidBST(TreeNode root) {
return isValidBSTCheck(root, Long.MIN_VALUE, Long.MAX_VALUE);
}
public boolean isValidBSTCheck(TreeNode root, long min, long max) {
if (root == null) return true;
if (root.val > min && root.val < max) {
return isValidBSTCheck(root.left, min, root.val) && isValidBSTCheck(root.right, root.val, max);
} else return false;
}
}```

# Algorithm Tips (1) – Avoiding Data Allocation

For next following posts, I will write down some tips when coding. These are all summaries while I practice on LeetCode. I know there are so many LeetCode answers of questions online, but that is a just question-to-answer model. If we just read the question and then answer it, we never grow up fast. We need to know why others’ algorithm is faster than mine and what’s the differences between them; in future, how can we apply others’ good places into our own. So, let’s start!

## Example-1:

We all know Map (key-value pair) is a good data structure to optimize algorithm speed sometimes. Because Map’s get speed is O(1) with well-designed hash function. But if we don’t write it well, it still might lose its advantage.

### Worse Case:

```Map<Integer, List<Integer>> map = new HashMap();
// nums is a int[] array.
for(int i=0; i< nums.length; i++) {
List<Integer> value = new ArrayList();
if (map.containsKey(i)) {
}
map.put(i, value);
}```

### Better Version:

```Map<Integer, List<Integer>> map = new HashMap();
for(int i=0; i<nums.length; i++) {
if (!map.containsKey(i)) {
map.put(i, new ArrayList<>());
}
}```

For small volume of data, this kind of advantage might be not too obvious, but for big data, the second version is much better than the first one.

It is quite easy to understand its improvement. For the first version, it has “addAll” to insert the whole list to another one. From physical side, we know it needs to handle a lot of things, such as allocating space. In fact, ArrayList.addAll already did some optimization, like allocating enough space to add every single element in one step, rather than having to reallocate multiple times if adding large numbers of elements. To avoid these things, the second version uses an empty data (” new ArrayList<>()” ) to well get rid of space allocation issue.

## Example-2:

The Question requests to design a set data structure that supports all operations in average O(1) time.

### Worse Version:

```List<Integer> data;
public boolean insert(int val) {
if (data.contains(val)) return false;
else {
return true;
}
}
public boolean remove(int val) {
if (data.contains(val)) {
int index = data.indexOf(val);
data.remove(index);
return true;
} else return false;
}```

### Better Version:

```List<Integer> data;
Map<Integer, Integer> map; // to store val->index
public boolean insert(int val) {
if (map.containsKey(val)) return false;
else {
map.put(val, data.size()-1);
return true;
}
}
public boolean remove(int val) {
if (!map.containsKey(val)) return false;
else {
int index = map.get(val);
if (index != data.size()-1) {
int lastValue = data.get(data.size()-1);
data.set(index, lastValue);
map.put(lastValue, index);
}
data.remove(data.size()-1);
map.remove(val);
return true;
}
}```

We see the great difference between the two version is that we introduce a Map to store each value’s index; for remove function, we swap the target with the last element of the list and then finally delete the last one.

The reason we improve like this is to reach O(1) purpose. ArrayList’s indexOf and remove method are opposite with this target.

• remove(int)
This method removes a single element at given position. After that all elements from the right are shifted to the left via System.arraycopy.all, so this method has O(n) complexity. Each call to remove the last element would not invoke System.arraycopy all, so such method call complexity would be O(1).
• remove(Object)
This method removes the first occurrence of a given element from the list. It iterates all list elements, so it has O(n) complexity. This method would access all array elements in any case – either read them while looking for requested element or move them from one position to the left by System.arraycopy call after requested element was found.
Never call remove(Object) when you know at which position you can find your element.
• contains(Object), indexOf(Object)
The first method checks a given object whether it’s present in the list (and defined as indexOf(elem)>=0). The second method tries to find the position of given element in the list. Both methods have O(n) complexity because they are scanning an internal array from the beginning in order to find given element.

### Summary of List:

• add elements to the end of the list
• remove elements from the end
• avoid contains, indexOf and remove(Object) methods
• even more avoid removeAll and retainAll methods
• use subList(int, int).clear() idiom to quickly clean a part of the list

# Renew Expired SSL Certification in Nginx Server

Each SSL Certification has its own valid date. When your server’s certification is expired, your website will be not visitable. In this case, you need to renew your expired certification. It is quite simple and easy. But Here I just write it down to record its steps.

## Step1: check its valid date

```openssl x509 -in domain.crt -noout -enddate
```

## Step2: copy the new certificate files to your server

This step depends on your service, I mean which SSL service you get. For me, I get this service from Godaddy. I need to go to Godaddy to get new crt files. There are two crt files which you need to download.

And then you need to use SCP command to copy these files to your server. If you forget the target location, you just need to go to your Nginx’s conf file to check this parameter: ssl_certificate and you will know where to copy to.

Here is an example of SSL part in Nginx.

```ssl on;
ssl_certificate /etc/ssl/domain.crt;
ssl_certificate_key /etc/ssl/domain.key;```

Here ssl_certificate is your primary certificate; ssl_certificate_key should be the key file generated when you created the CSR.

Please note, this part is just to update expired SSL certificate so you don’t need to do anything on the key file.

## Step3: concatenate the SSL certificate and intermediate certificate

In fact, you need to backup or remove the existing expired domain.crt first and the do concatenate. Just for safe.

`cat 29393****.crt gd_bundle-g2-g1.crt >> domain.crt`

## Step4: restart Nginx

`sudo nginx -s reload`

# Scala – Performance Optimization

First, we talked lot of information about performance optimization, including slick’s performance optimization by connection pool, JavaScript High Performance tips, MySQL’s performance tuning, and Play Framework Tuning(1) and Tuning(2). If we think it is enough, we are too naive. This post I will list performance optimization tips on Scala.

1. par
If we have N tasks which don’t have any relationship between each task, like order, shared variable, we can consider using the parallel collection to fasten computation.
The parallel collection will make use of max-currency depending on the number of cores to execute which will greatly improve function’s efficiency.

```val list = List[String]("a", "b", "c", ...)
list.par.foreach( r => {
})```

Note:
Sometimes, the sequential implementation might have better performance than parallel implementation. That’s because using parallel collection has some overhead for distributing(fork) and gathering(join) the data between cores. Thus one can conclude having heavy computations, parallel collections can be of great performance improvement.

2. Future
Future is the same with par which can reach to the same purpose.

```import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Await, Future}
import scala.concurrent.duration._```
```val arr = List[String]("a", "b", "c")
val futures = arr.map( r => Future {
})
val future = Future.sequence(futures)
Await.result(future, 1 hour)```
3. Avoid unnecessary loop
Even though we have  the parallel method to fasten steps, avoiding unnecessary loop is still needed. For my code, I use the random method to handle tokens selection problem to make sure the resources are fair to every customer. This is benefit from the probability theory.
4. print out thread name to debug parallel running status
`println(Thread.currentThread().getName)`
5. Separate ExectureContent
If you don’t want to influence default ExectureContent, you can create additional one to separate it.

`implicit val ec = ExecutionContext.fromExecutor(Executors.newCachedThreadPool())`

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue. At any point, at most nThreads threads will be active processing tasks. If additional tasks are submitted when all threads are active, they will wait in the queue until a thread is available. If any thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks. The threads in the pool will exist until its is explicitly shutdown.
Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available. These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks. Calls to execute will reuse previously constructed threads if available. If no existing thread is available, a new thread will be created and added to the pool. Threads that have not been used for sixty seconds are terminated and removed from the cache. Thus, a pool that remains idle for long enough will not consume any resources. Note that pools with similar properties but different details (for example, timeout parameters) may be created using ThreadPoolExecutor constructors.

# Server Protection and Monitor

As we all know, there is a huge DDoS attack recently which influences lots of websites. At first beginning, our server didn’t get influenced by it. But last week, I allow ssh server by password.(In the past, we only allow the user to use the public key to ssh server. But last week, we just want to allow a user to log in simply and fast. We open it temporarily and forget to close it) This week, the server is totally attacked. Anyway, the final problem is that our server is blocked by increasing useless threads and bandwidth is used up. So here I list how I find these problems and how we try to fix it.

## Step1: check network status

According to check network status, you will find bandwidth is too high which influences other normal customers to use this server’s resources.

```sudo apt-get install nethogs
sudo nethogs
sudo nethogs eth0 eth1```

Except knowing the bandwidth status, you also need to know thread status. By viewing real-time thread status, you will know there are many malicious threads which take too many resources. For my case, I find there are 300 malicious threads which are created every 2 minutes. It is not hard to understand that the final server is slow enough to undertake these increasing malicious threads.

```sudo apt-get install htop
htop```

After known these malicious threads, we need to kill them. In fact, killing them can solve this problem by root cause. Because for now I only know its effect, not the root cause. Luckily we find a bash script which causes it. So I kill this bash script together. Until now, it looks like we already finish everything. But things haven’t done. After 8 hours stable network, the server is attacked again. I can’t ssh into the server. So final solution is to shut down and rebuild the server. So for now, I don’t know the root cause.

`sudo kill -9 \$(pgrep <useless_threads_main_name>)`

In order to avoid the attack happens again, I involve public key back. Because I’m sure this attack happened when I open password login.

`ssh <user_name>@<server_ip> 'mkdir -p ~/.ssh;cat >> ~/.ssh/authorized_keys' < ~/.ssh/id_rsa.pub`

Here id_rsa.pub is your own public key file.

## Step5: disable password to ssh

`sudo vi /etc/ssh/sshd_config`
```# change to no to disable tunnelled clear text passwords
`service ssh restart`