var spawn = require('child_process').exec;

hexo.on('new', function(data){
  spawn('start  "markdown编辑器绝对路径.exe" ' + data.path);
});

require('shelljs/global');//记得安装包

try {
	hexo.on('deployAfter', function() {//当deploy完成后执行备份
		run();
	});
} catch (e) {
	console.log("You make a wrong：" + e.toString());
}

function run() {
	if (!which('git')) {
		echo('Sorry, this script requires git');
		exit(1);
	} else {
		echo("======================Auto Backup Begin===========================");
		cd('./');
		if (exec('git add --all').code !== 0) {
			echo('Error: Git add failed');
			exit(1);

		}
		if (exec('git commit -am "Form auto backup script\'s commit"').code !== 0) {
			echo('Error: Git commit failed');
			exit(1);

		}
		if (exec('git push origin source').code !== 0) {
			echo('Error: Git push failed');
			exit(1);

		}
		echo("==================Auto Backup Complete============================")
	}
}

class Solution {
    public int mySqrt(int x) {
        long n = 1;
        while(n * n <= x) {
            n++;
        }
        return (int) n - 1;
    }
}
Runtime: 11 ms

Given two binary trees, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical and the nodes have the same value.

Example 1:

Input:     1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

Output: true
Example 2:

Input:     1         1
          /           \
         2             2

        [1,2],     [1,null,2]

Output: false
Example 3:

Input:     1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

Output: false

class Solution {
  public boolean isSameTree(TreeNode p, TreeNode q) {
    // p and q are both null
    if (p == null && q == null) return true;
    // one of p and q is null
    if (q == null || p == null) return false;
    if (p.val != q.val) return false;
    return isSameTree(p.right, q.right) &&
            isSameTree(p.left, q.left);
  }
}

Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in-place.

Example 1:

Input: 
[
  [1,1,1],
  [1,0,1],
  [1,1,1]
]
Output: 
[
  [1,0,1],
  [0,0,0],
  [1,0,1]
]
Example 2:

Input: 
[
  [0,1,2,0],
  [3,4,5,2],
  [1,3,1,5]
]
Output: 
[
  [0,0,0,0],
  [0,4,5,0],
  [0,3,1,0]
]
Follow up:

A straight forward solution using O(mn) space is probably a bad idea.
A simple improvement uses O(m + n) space, but still not the best solution.
Could you devise a constant space solution?

public void setZeroes(int[][] matrix) {
    int rows = matrix.length-1;
    int cols = matrix[0].length-1;
    regression(matrix, rows>=cols?cols:rows);
}
public void regression(int[][] matrix,int index){
    if(index<0){
        return;
    }
    boolean flag = false;
    for(int i =index;i<matrix[0].length;i++){
        if(matrix[index][i]==0)
        {
            handleZero(matrix,i);
            flag=true;
            break;
        }
    }
    if(flag==false){
        for(int j =index;j<matrix.length;j++){
            if(matrix[j][index]==0)
            {
                handleZero(matrix,j);
                break;
            }
        }
    }

    regression(matrix, --index);
}
private void handleZero(int[][] matrix,int pos) {

    for(int i=matrix[0].length-1;i>=pos;i--){
        matrix[pos][i]=0;
    }
    for(int j=matrix.length-1;j>=pos;j--){
        matrix[j][pos]=0;
    }
}

class Solution {
  public void setZeroes(int[][] matrix) {
    int R = matrix.length;
    int C = matrix[0].length;
    Set<Integer> rows = new HashSet<Integer>();
    Set<Integer> cols = new HashSet<Integer>();

    for (int i = 0; i < R; i++) {
      for (int j = 0; j < C; j++) {
        if (matrix[i][j] == 0) {
          rows.add(i);
          cols.add(j);
        }
      }
    }

    for (int i = 0; i < R; i++) {
      for (int j = 0; j < C; j++) {
        if (rows.contains(i) || cols.contains(j)) {
          matrix[i][j] = 0;
        }
      }
    }
  }
}

class Solution {
    public void setZeroes(int[][] matrix) {
		int R = matrix.length;
		int C = matrix[0].length;
		boolean isCol = false;
		
		for(int i=0; i<R; i++) {
			if (matrix[i][0] == 0) {
		        isCol = true;
		    }
			for(int j=1; j<C; j++) {
				if(matrix[i][j]==0) {
					matrix[0][j] = 0;
					matrix[i][0] = 0;
				}	
			}
		}
		
		// Iterate over the array once again and using the first row and first column, update the elements.
		for(int i=1; i<R; i++) {
			for(int j=1; j<C; j++) {
				if(matrix[i][0]==0 || matrix[0][j]==0) {
					matrix[i][j] = 0;
				}
			}
		}
		
		// See if the first row needs to be set to zero as well
		if(matrix[0][0]==0) {
			for(int j=0; j<C; j++) {
				matrix[0][j] = 0;
			}
		}
		
		// See if the first column needs to be set to zero as well
		if(isCol) {
			for(int i=0; i<R; i++) {
				matrix[i][0] = 0;
			}
		}
    }
}

> MULTI
OK
> INCR foo
QUEUED
> INCR bar
QUEUED
> EXEC
1) (integer) 1
2) (integer) 1

MULTI
+OK
SET a abc
+QUEUED
LPOP a
+QUEUED
EXEC
*2
+OK
-ERR Operation against a key holding the wrong kind of value

{
    name:stu
    time:1
}

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Example:

Input:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
Output: 7
Explanation: Because the path 1→3→1→1→1 minimizes the sum.

class Solution {
    public int minPathSum(int[][] grid) {
        for(int i=1; i<grid.length; i++) grid[i][0] += grid[i-1][0];
        for(int j=1; j<grid[0].length; j++) grid[0][j] += grid[0][j-1];
        for (int i=1; i<grid.length; i++) {
            for (int j=1; j<grid[0].length; j++) {
                grid[i][j] = Math.min(grid[i][j-1], grid[i-1][j]) + grid[i][j];
            }
        }
        return grid[grid.length-1][grid[0].length-1];
    }
}

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not suppose to use the library's sort function for this problem.

Example:

Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]
Follow up:

A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.
Could you come up with a one-pass algorithm using only constant space?

可以添加任务，任务包含任务数据，任务延迟触发的等待时间。
在任务到达触发时间点时，自动触发执行此任务。
队列中任务保持先进先出原则：假设 A 任务的触发等待时间为 X，B 任务的触发等待时间为 Y，B 在 A 之后被添加入队列，则 A 的前驱任务执行完成后等待时间 X 后，才执行 A，同理在 A 执行完成后，等待时间 Y，才执行 B。