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];
    }
}