xlrd,xlwt有65536行的限制，所以以后使用openpyxl.
语法有所不同，坑点是后者行列号下表从1开始。

打开excel

1
2

filename = r'\filename.xlsx'
inwb = load_workbook(filename)

获取打开的excel的sheet内容

1
2

sheetnames = inwb.get_sheet_names()#获取读文件中所有的sheet，通过名字的方式
ws = inwb.get_sheet_by_name(sheetnames[0])#获取第一个sheet内容

获取sheet的最大行数和列数

1

rows = ws.max_row

获取某个单元格的值

1
2

lng = ws.cell(row = i+1 , column = 4).value
lat = ws.cell(row = i+1 , column = 5).value

打开将写的表并添加sheet

1
2

outwb = Workbook()#打开一个将写的文件
outws = outwb.create_sheet(title="cool")#在将写的文件创建sheet

将数据写入sheet

1
2

outws.cell(row = i+1 , column = 1, value = result[0])
outws.cell(row = i+1 , column = 2, value = result[1])

保存

1

outwb.save('answer.xlsx')#一定要记得保存

:代表该参数需要值

1
2
3
4
5
6
7
8
9
10
11
12
13

opts,args = getopt.getopt(sys.argv[1:],'-h-f:-v',['help','filename=','version'])
for opt_name,opt_value in opts:
    if opt_name in ('-h','--help'):
        print("[*] Help info")
        exit()
    if opt_name in ('-v','--version'):
        print("[*] Version is 0.01 ")
        exit()
    if opt_name in ('-f','--filename'):
        fileName = opt_value
        print("[*] Filename is ",fileName)
        # do something
        exit()

原文

基本语法

hexo中math插件对mathjax的支持存在问题。比如_和\的转义，所以矩阵换行的\\语法变成\\\。

呈现位置

• 正文(inline)中的LaTeX公式用$...$·定义
• 语句为$\sum_{i=0}^N\int_{a}^{b}g(t,i)\text{d}t$,显示当前行内$\sum_{i=0}^N\int_{a}^{b}g(t,i)\text{d}t$
• 单独显示(display)的LaTeX公式用$$...$$定义，此时公式居中并放大显示
  $$\sum_{i=0}N\int_{a}{b}g(t,i)\text{d}t$$

  希腊字母

• 若需要大写希腊字母，将命令首字母大写即可。
• 若需要斜体希腊字母，将命令前加上var前缀即可。

字母修饰

上下标

• 上标：^
• 下标：_

  矢量

• \vec a $\vec a$
• \overrightarrow{xy} $overrightarrow{xy}$

  字体

• Typewriter: \mathtt{A} $\mathtt{A}$
• Blackboard: \mathbb{A} $\mathbb{A}$
• Sans Serif: \mathsf{A} $\mathsf{A}$

  分组

• 使用{}将具有相同等级的内容括入其中
• 10^{10} $10^{10}$

  括号

• 小括号：()
• 中括号：[]
• 尖括号：\langle,\rangle
• (\frac{x}{y}) $(\frac{x}{y})$
• \left(\frac{x}{y}\right) $\left(\frac{x}{y}\right)$

  求和、极限与积分

• 求和：\sum_{i=1}^n{a_i} $\sum_{i=1}^n{a_i}$
• 极限：\lim_{x\to 0} $\lim_{x\to 0}$
• 积分：\int_0^\infty{f(x)dx} \int_0^\infty{f(x)dx}

  分式与根式

• \frac{x}{y} $\frac{x}{y}$
• \sqrt[x]{y} $\sqrt[x]{y}$

  特殊函数

• \函数名
• $ \sin{x} $,$ \ln{x} $,$ \max(A,B,C) $

  特殊符号

空格

• 小空格：a\ b $a\ b$
• 4位空格： a\quad b $a\quad b$

  矩阵

  基本语法

• \begin{matrix},\end{matrix}
• 行末尾标记\\,行间元素以&分割

  1 2 3 4 5

  $$\begin{matrix} 1&0&0\\\ 0&1&0\\\ 0&0&1\\\ \end{matrix}$$

$$\begin{matrix}
1&0&0\
0&1&0\
0&0&1\
\end{matrix}$$

矩阵边框

在开始和结束标记处用下列词语替换

• pmatrix 小括号边框
• bmatrix 中括号边框
• Bmatrix 大括号边框
• vmatrix 单竖线边框
• Vmatrix 双竖线边框

省略元素

• 横省略号 \cdots $\cdots$
• 竖省略号 \vdots $\cdots$
• 斜省略号 \ddots $\cdots$

  1 2 3 4 5 6

  $$\begin{bmatrix} {a_{11}}&{a_{12}}&{\cdots}&{a_{1n}}\\ {a_{21}}&{a_{22}}&{\cdots}&{a_{2n}}\\ {\vdots}&{\vdots}&{\ddots}&{\vdots}\\ {a_{m1}}&{a_{m2}}&{\cdots}&{a_{mn}}\\ \end{bmatrix}$$

$$\begin{bmatrix}
{a_{11}}&{a_{12}}&{\cdots}&{a_{1n}}\
{a_{21}}&{a_{22}}&{\cdots}&{a_{2n}}\
{\vdots}&{\vdots}&{\ddots}&{\vdots}\
{a_{m1}}&{a_{m2}}&{\cdots}&{a_{mn}}\
\end{bmatrix}$$

阵列

• 标记 {array}
• 对齐方式： 在{array}后逐行统一声明
  • 左对齐： l；居中：c；右对齐：r
  • 竖直线： 在声明对齐方式时，插入|建立竖直线
• 插入水平线： \hline

  1 2 3 4 5 6

  $$\begin{array}{c|lll} {↓}&{a}&{b}&{c}\\ \hline {R_1}&{c}&{b}&{a}\\ {R_2}&{b}&{c}&{c}\\ \end{array}$$

$$\begin{array}{c|lll}
{↓}&{a}&{b}&{c}\
\hline
{R_1}&{c}&{b}&{a}\
{R_2}&{b}&{c}&{c}\
\end{array}$$

方程组

• {cases}

  1 2 3 4 5 6

  $$\begin{cases} a_1x+b_1y+c_1z=d_1\\ a_2x+b_2y+c_2z=d_2\\ a_3x+b_3y+c_3z=d_3\\ \end{cases} $$

$$\begin{cases}
a_1x+b_1y+c_1z=d_1\
a_2x+b_2y+c_2z=d_2\
a_3x+b_3y+c_3z=d_3\
\end{cases}
$$

参考文献

MathJax tutorial

补充 特殊符号

希腊字母和希伯来字母

逻辑运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

官方数据很水，O(n+m)的复杂度就给过了，按照题目要求做。
中位数就是把一组数据分为两个长度相等的数据组，log(m+n)的复杂度并且数组有序，很自然得想到二分。受到限制的是，这个两个数组分别有序，即使合并也会有n+m的复杂度。所以，不可能每个数据都访问，要同时二分。主要目的就是分成两个长度相等的数据组，所以可以二分得调两个数组个数直到相等。要处理好边界。

官方题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m, n;
        m = nums1.size();
        n = nums2.size();
        if(m>n)
        {
            swap(nums1, nums2);
            swap(m, n);
        }
        int iMin = 0, iMax = m, halfLen = (m+n+1)>>1;
        while(iMin<=iMax)
        {
            int i = (iMin + iMax)>>1;
            int j = halfLen - i;
            if(i<iMax&&nums2[j-1]>nums1[i])
                iMin = i+1;
            else if(i>iMin && nums1[i-1]>nums2[j])
                iMax = i-1;
            else
            {
                int maxLeft = 0;
                if(i==0)
                    maxLeft = nums2[j-1];
                else if(j==0)
                    maxLeft = nums1[i-1];
                else
                    maxLeft = max(nums1[i-1], nums2[j-1]);
                if((m+n)&1)
                    return maxLeft;
                
                int minRight = 0;
                if(i==m)
                    minRight = nums2[j];
                else if(j==n)
                    minRight = nums1[i];
                else
                    minRight = min(nums2[j], nums1[i]);
                return (maxLeft+minRight)/2.0;
            }
        }
        return 0;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

总时间限制: 1000ms 内存限制: 65536kB
描述

少年李逍遥的婶婶病了，王小虎介绍他去一趟仙灵岛，向仙女姐姐要仙丹救婶婶。叛逆但孝顺的李逍遥闯进了仙灵岛，克服了千险万难来到岛的中心，发现仙药摆在了迷阵的深处。迷阵由M×N个方格组成，有的方格内有可以瞬秒李逍遥的怪物，而有的方格内则是安全。现在李逍遥想尽快找到仙药，显然他应避开有怪物的方格，并经过最少的方格，而且那里会有神秘人物等待着他。现在要求你来帮助他实现这个目标。
下图显示了一个迷阵的样例及李逍遥找到仙药的路线.

输入

输入有多组测试数据. 每组测试数据以两个非零整数 M 和 N 开始，两者均不大于20。M 表示迷阵行数, N 表示迷阵列数。接下来有 M 行, 每行包含N个字符,不同字符分别代表不同含义:
1) ‘@’：少年李逍遥所在的位置；
2) ‘.’：可以安全通行的方格；
3) ‘#’：有怪物的方格；
4) ‘*’：仙药所在位置。
当在一行中读入的是两个零时，表示输入结束。
输出

对于每组测试数据，分别输出一行，该行包含李逍遥找到仙药需要穿过的最少的方格数目(计数包括初始位置的方块)。如果他不可能找到仙药, 则输出 -1。
样例输入

8 8
.@##...#
#....#.#
#.#.##..
..#.###.
#.#...#.
..###.#.
...#.*..
.#...###
6 5
.*.#.
.#...
..##.
.....
.#...
....@
9 6
.#..#. 
.#.*.# 
.####. 
..#... 
..#... 
..#... 
..#... 
#.@.## 
.#..#. 
0 0


样例输出

10
8
-1

使用栈进行dfs，统计步数，取最小。
也可bfs，bfs搜到目标即可停止搜索。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<stack>
const int INF = (1<<31)-1;
using namespace std;

typedef struct
{
	int x,y,depth;
}Point;
char maze[50][50];
int vis[50][50];
stack<Point> s;
int dx[] = {0,0,1,-1};
int dy[] = {1,-1,0,0};

int main()
{
	int M,N;
	int minstep, stepcnt;
	Point L, Tar;
	while(cin>>M>>N)
	{
		minstep = INF;
		stepcnt = 0;
		if(!M&&!N)
			break;
		getchar();
		for(int i=0;i<M;++i)
		{
			for(int j=0;j<N;++j)
			{
				scanf("%c", &maze[i][j]);
				vis[i][j] = 0;
				if(maze[i][j]=='@')
					L.x=i, L.y=j, L.depth=0;
				else if(maze[i][j] == '*')
					Tar.x = i, Tar.y = j;
			}
			getchar();
		}
		/*
		for(int i=0;i<M;++i)
		{
			for(int j=0;j<N;++j)
			{
				printf("%c", maze[i][j]);
			}
			putchar('\n');
		}
		*/
		s.push(L);
		while(!s.empty())
		{
			Point t = s.top();
			//cout<<t.x<<','<<t.y<<','<<t.depth<<endl;
			if(t.x==Tar.x&&t.y==Tar.y)
			{
				minstep = minstep<t.depth? minstep:t.depth;
				s.pop();
				continue;
			}
			vis[t.x][t.y] = 1;
			s.pop();
			for(int i=0;i<4;++i)
			{
				Point tmp;
				tmp.x = t.x+dx[i];
				tmp.y = t.y+dy[i];
				tmp.depth = t.depth+1;
				if(maze[tmp.x][tmp.y]!='#'&&!vis[tmp.x][tmp.y]&&tmp.x>=0&&tmp.x<M&&tmp.y>=0&&tmp.y<N)
				{
					//cout<<'>'<<tmp.x<<','<<tmp.y<<endl;
					s.push(tmp);
				}

			}
		}
		cout<<(minstep==INF?-1:minstep)<<endl;
	}

	return 0;
}