​ ​ ​


苏哥的第一篇博客

我的第一篇blog，可以显示中文（哦哈哈）和公式了（$1\neq 2$)

and $$\int_0^1 x dx =\frac{1}{2}$$

还有就是，另一个域名 algebraic.top 需要备案这个域名，才能指过来，此域名一狠心续费了10年。。。

  view

New planning

今天11月24，第11周的周六。博士阶段第一学期的课开始进入收尾，下周三考完AG，要马上开始接触双曲。初步计划如下： 今天11月29，第12周的周四，时间过得真快！！！繁忙的生活依然在今天持续，信息办OK，农行ok，财务处ok，系统显示ok，导入失败，我要赶紧把这些抛之脑后。明天开始终于有连续5天的自由时间，渴望是真正的自由，无琐无杂。接下来好好算计一下。

现阶段首要了解的 Gromov. Hyperbolic group. Hyperbolic manifold and discrete group

基础必备的 charisteristic class, spectral, index theorem.

暂时的问题及方向 when is there exist hyperbolic metric on a manifold with coners. how to define these mertic or find some good conditions on manifold. the relation between the isomorphism of the fundamental groups of manifolds with coners and the homeomorphism of manifolds. can we prove that the broel consjecture in this categorie, or just small covers.

Geometry: cruvature--constant negative sectional cruvature; CAT(k) space; folw;

Group: hyperbolic group; whitehead group of fundamental group.

Combination:

more and more ----

按时毕业
  view

Flag

I shall to prove the Borel conjecture for small covers in dimension 4, even give a description for the classification of 4-small cover.

my plan
  view

聊一聊人生

今天，6月27，虽是雨后，但仍是闷热。

想一想，上研究生这三年自己做过什么，一片空白！唯一的收获，经历了一段本早该经历但不该在这三年经历的事--一场 亦真亦假的感情经历，，，（省略掉！）

我原来想做什么？可能三年前，我就不是很明确，就记得身边同学都去考研了，我也跟着去了，也没啥毅力与期望， 有点稀里糊涂、莫名其妙。可现在，26的我已经把自己束缚到这根漂亮的栓蚂蚱的猫尾草上了。不过还好，做一个学生， 在学校里，身边的人都很单纯，都很拼地做着他们的事情，他们中很多人对数学的执着与热爱，让我深深敬佩。 和单纯优秀的人呆在一起，很安心，很惬意。就是回家，还可以老朋友聊聊我的这些老师和同学如何如何的厉害， 仿佛我也因为认识厉害的一个群体而自豪。。而我呢？现在大概也在这样的群体里，因为自己的原因，还只是在边缘上。 一个空间或者概念的边缘都是不稳定的，特殊的，痛苦而又纠结的。

现在的我好像清醒似的。知道自己该做什么，该怎么做，该以怎样的心态去面对变化不定的人生，该以如何如何的努力 去把握心仪向往的目标。不想想那么多，甚至除了主枝外的所有枝枝叶叶都不去考虑，就羡慕着和别人一样，抛开外面的 一切去做自己喜欢的事。

以后很可能是孤独的，我时时刻刻都有着这样的准备。己所不欲，勿施于人！特别是感情上的事不该去勉强，但愿我能 一直怀一分单纯青涩，不求结果。无论如何，都要安静下来了，已经失去了三年，接下来的三年是来之不易的幸运。祝我 身边的所有人都可以心想事成。 <li> 基础专业课中，微分拓扑我学得绝对糟糕的很！接下来这两个月，要把微分拓扑、示性类，外加一点李群和拓扑群都补上。 <li> 自己的那个问题也不能放下，毕竟还是很有可能解决的。大牛做剩下的，如果我做出来了，哈哈肯定会很开心！ <li> 要自己写一篇英文文章，认认真真的每天完成。 <li> 放轻松，不勉强，，开心的在这，在一起过一段时间。

突然发现也没什么想写的。三年之后，只希望自己回首三年，可以数数做过的几件事情。

2018年于临沂市万阅城--扯淡！

生活
  view

caffe 安装

caffe 深度学习开源框架

###安装了 visual stdio 2015 Anaconda3-5.1.0-Windows-x86_64 cuda_9.1.85_win10 cudnn-9.1-windows10-x64-v7.1

每天把Matlab安装上，有点多啊

  view

动态规划

参考 https://blog.csdn.net/yuxin6866/article/details/52507623

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#动态规划之背包问题
#问题描述：一个包，承重量为V，N件物品，第i件物品重量c_i价值w_i。问：可装最大价值
#数学模型：已知A_{2*(N+1)}，第一行价值，第二行重量
#         一个f_{(N+1)*V}记录矩阵，初值f(1,j)=0
#         子问题：f(i,v)=max{f(i-1,j),f(i-1,v-c_i)+w_i}
N=5
V=120
A=[[0,40,50,70,40,20],[0,10,25,40,20,10]]
f=[[0 for j in range(V+1)] for i in range(N+1)]
for i in range(N+1):
    for j in range(V+1):
        if A[0][i]>j:
            f[i][j]=f[i-1][j]
        else:
            f[i][j]=max(f[i-1][j],f[i-1][j-A[0][i]]+A[1][i])
print(f[N][V])

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
#动态规划之最长公共子序列LCS(Longest Common Subsequence)
#问题描述：cnblogs与belong，最长公共子序列为blog
#数学模型：两个序列为s_i，n_i=len(s_i)，i=1,2
#          f_{(n_1+1)*(n_2+1)}
#          初值：f(0,j)=f(i,0)=0
#          状态转移：
#                 若s_1[i]=s_2[j],则f(i,j)=f(i-1,j-1)+1
#                 否则  f(i,j)=max{f(i,j-1),f(i-1,j)}
#并给出所有LCS
s_1='cnblogs'
s_2='belong'
n_1=len(s_1)
n_2=len(s_2)
f=[[0 for j in range(n_2+1)] for i in range(n_1+1)]
for i in range(1,n_1+1):
    for j in range(1,n_2+1):
        if s_1[i-1]==s_2[j-1]:
            f[i][j]=f[i-1][j-1]+1
        else:
            f[i][j]=max(f[i-1][j],f[i][j-1])
print(f[n_1][n_2])#LCS的最大长度
######求LCS
s=[]
t=[]
W=[]
#####
#公共子串
#问题描述：cnblogs与belong，最长公共子串为lo
#          状态转移：
#                 若s_1[i]=s_2[j],则f(i,j)=f(i-1,j-1)+1
#                 否则  f(i,j)=0
#并给出所有最长公共子串
lenn=0
g=[[0 for j in range(n_2+1)] for i in range(n_1+1)]
for i in range(1,n_1+1):
    for j in range(1,n_2+1):
        if s_1[i-1]==s_2[j-1]:
            g[i][j]=g[i-1][j-1]+1
            lenn=max(g[i][j],lenn)
        else:
            f[i][j]==0
print(lenn)#LCS的最大长度
######求公共子串
s=[]
t=[]
W=[]
#####

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#动态规划之KMP算法
#现有1 5 10 20 50 100等6种面额票子，任意S,求最少张的票子组合
#S=sum x_i*a_i 使得 f=sum x_i 最小
#初值 f(1)=f(5)=f(10)=f(20)=f(50)=f(100)=1
S=int(input())
A=[1,5,10,20,50,100]
f=[0 for i in range(S+1)]
minnn=100000 #最大初值
for i in range(1,S+1):
    if i in A:
        f[i]=1
        continue
    minn=minnn
    for j in A:
        if i-j>0:
            minn=min(f[i-j],minn)    
    f[i]=minn+1
print(f[S])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#动态规划平方个数最小问题
#n=sum(x_i^2),i=1,2,...,n 求最小n
#12=4+4+4 n=3
n=13
f=[0 for i in range(n+1)]
for i in range(n+1):
    minn=i
    j=1
    while j*j<=i:
        minn=min(f[i-j*j]+1,minn)
        j+=1
    f[i]=minn
print(f[n])

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
#动态规划之最长回文串
#p[i:j]的子问题是p[i+1:j-1]
s='abba'
s=list(s)
n=len(s)
maxlen=1
start=0
f=[[False for i in range(n)] for j in range(n)]
#初始化，
for i in range(n):
    f[i][i]=True
    if i<n-1 and s[i]==s[i+1]:
        f[i][i+1]=True
        start=i
        maxlen=2
for k in range(3,n+1):
    for i in range(n-k):
        j=i+k-1
        if f[i+1][j-1] and s[i]==s[j]:
            f[i][j]=True
            maxlen=k
            start=i
print(''.join(s[start-1:(start+maxlen+1)]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#动态规划之最长递增序列
l=[2,3,5,2,6]
n=len(l)
f=[0 for i in range(n)]
for i in range(n):
    f[i]=1
    for j in range(i):
        if l[i]>l[j] and f[j]+1>f[i]:
            f[i]=f[j]+1
max_l=f[0]
for i in range(n):
    if f[i]>max_l:
        max_l=f[i]
print(max_l)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#楼层扔珠子问题
#某楼有100层。你手里有两颗玻璃珠。
#当你拿着玻璃珠在某一层往下扔，一定会有两个结果，玻璃珠碎了或者没碎。
#这幢大楼有个临界楼层。低于楼层，玻璃珠不会碎，等于或高于，玻璃珠一定会碎。
#玻璃珠碎了就不能再扔。
#现在让你设计一种方式，使得在该方式下，最坏的情况扔的次数最少。
#例如：第一次选择在60层扔，
#若碎了，说明临界点在60层及以下楼层，
#这时只有一颗珠子，剩下的只能是从第一层，一层一层往上实验，
#最坏的情况，要实验59次，加上之前的第一次，一共60次。
#若没碎，则只要从61层往上试即可，最多只要试40次，加上之前一共需41次。
#两种情况取最多的那种。故这种方式最坏的情况要试60次。
n=100 #100层
f=[0 for i in range(101)]
for i in range(2,n+1):
    f[i]=i
    for j in range(i):
        f[i]=min(f[i],max(j,1+f[i-j]))
print(f[n])

  view

杂记

幸运舍友，可以免面试去实习。弄得我忐忑了一下，对方的建议廖雪峰的python教程看到程序调试那， 今天也慌张的加速到那了。然后试了几个SQL语句，感觉还记得点。然后练练程序题，选了通过率最低的一个。 也是废了半天老大劲，描述如下

###题目描述 给定一个十进制的正整数number，选择从里面去掉一部分数字，希望保留下来的数字组成的正整数最大。 ###输入描述: 输入为两行内容，第一行是正整数number，1 ≤ length(number) ≤ 50000。第二行是希望去掉的数字数量 cnt 1 ≤ cnt < length(number)。 输出描述: 输出保留下来的结果。

第一个是自己运行了n次，终于有个70或者80的通过率，思路是我从左向右找出前len-k位 ，最大的数，把这个数前的cut掉， 对后面的数进行同样的操作. 借鉴三查出个bug,就是我不断的提最大忘了控制，然后改下，并借鉴优化一下得到90通过，最后通过是最后一个 ，但运行时间有点长，max和index函数的原因.

别人的思路，2和3，删掉左起下降的项。

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def findlnum(l,k):
    i=l.index(max(l[0:k+1]))
    return l[i:len(l)],k-i
n=int(input())
k=int(input())
l,re=[],0
K=len(l)-k
while n>0:
    l.insert(0,n%10)
    n=n//10
if  len(l)> K:
    nums = nums[:K]
while l!=[]:
    (l,k)=findlnum(l,k)
    re=re*10+l[0]
    l=l[1:len(l)]
print(re)
#####%80
n=int(input())
k=int(input())
l,re=[],0
while n>0:
    l.insert(0,n%10)
    n=n//10
while k>0:
    for i in range(len(l)):
        if l[i]<l[i+1]:
            l.pop(i)
            k-=1
            break
for i in range(len(l)):
    re=re*10+l[i]
print(re)
##%70
nums = list(input())
cnt = int(input())
n, j, i= len(nums), cnt, 0
while j > 0 and i < n-1:
    if nums[i]>= nums[i+1]:
        i += 1
    else:
        nums.pop(i)
        j -= 1
        n -= 1
        i = i-1 if i > 0 else 0
if j > 0:
    nums = nums[:-j]
print(''.join(nums))
运行时间：59ms
占用内存：3700k
def findlnum(l,k):
    i=l.index(max(l[0:k+1]))
    return l[i:len(l)],k-i
l=list(input())
k=int(input())
re=[]
K=len(l)-k
while l!=[]:
    (l,k)=findlnum(l,k)
    if k==0:
        re.extend(l)
        break
    re.append(l[0])
    l=l[1:len(l)]
re=re[0:K]
print(''.join(re))
运行时间：606ms
占用内存：4016k
def findlnum(l,k):
    i=l.index(max(l[0:k+1]))
    return l[i:len(l)],k-i
l=list(input())
k=int(input())
re,j=[],0
K=len(l)-k
while l!=[] and j<K:
    (l,k)=findlnum(l,k)
    if k==0:
        re.extend(l)
        break
    re.append(l[0])
    l=l[1:len(l)]
    j+=1
print(''.join(re))
运行时间：403ms
占用内存：4908k

  view
```
```