1. Modify nq2 and nq3(float map for input) of Newcoder.

mjjackey · mjjackey · commit c912c1162794 · 2020-07-21T14:50:27.000+08:00
2. Add Espressif 2020_Algorithm and 2020 Soft.

Signed-off-by: Jackey &lt;smjjackey@sina.com&gt;
diff --git a/Espressif/2020_Algorithm/e1.py b/Espressif/2020_Algorithm/e1.py
@@ -0,0 +1,56 @@
+"""
+ 在证明数素无穷性时，使用了一个表达式 N＝2＊3＊5＊7＊11…….＊P + 1，其中 P 为一个素数，N 是 2 到 P 中所有素数的乘积加 1，
+ 若 P 为最大的素数，可以反证出 N 也是素数，从而证明素数是无穷多的。
+ 但有人因此认为，所有的 N 都是素数。如N0 = 3 为 素数，N1 = 7 为素数，N2 = 31 为素数。请判断第 i 个 N 是否为素数。
+
+In: 每组输入只有一行，包含一个整数i(0 <= i <= 14)，表示要检查的是第i个N。
+Out: 输出只有一行，若Ni为素数，打印“Ni is a prime”，否则打印“Ni is not a prime”。
+
+e.g.
+In: 1
+Out: 7 is a prime
+"""
+import  math
+def _odd_iter():
+    n = 1
+    while True:
+        n = n + 2
+        yield n
+
+def _not_divisible(n):
+    """
+    :param n: known number, x is the element of the sequence
+    :return: bool
+    """
+    return lambda x: x % n > 0
+
+def primes():
+    yield 2
+    it = _odd_iter()
+    while True:
+        n = next(it)
+        yield n
+        it = filter(_not_divisible(n), it)
+
+def fun(i):
+    # prime_list=iter(primes())[:i]
+    prime_list=[]
+    for num in primes():
+        prime_list.append(num)
+        if(len(prime_list)==i+1): break
+    # print(prime_list)
+    prod=1
+    for num in prime_list:
+        prod=prod*num
+    n=prod+1
+    flag=False
+    for j in range(2,int(math.sqrt(n))+1):
+        if(n%j==0):
+           flag=True
+           break
+    if(flag): print(str(n)+" is not a prime")
+    else: print(str(n)+ " is a prime")
+
+if __name__ == "__main__":
+    i= int(input().strip())
+    fun(i)
diff --git a/Espressif/2020_Algorithm/e2.py b/Espressif/2020_Algorithm/e2.py
@@ -0,0 +1,104 @@
+"""
+求矩阵像素的最大连通域，像素为1的pixel周围8*8的像素为1的pixel都是它的邻接点，连接性具有传递性，pixel a与
+pixel b连通，b与c连通，则a与c连通，所以找到邻接点后再找邻接点的邻接点。
+试找出一个二值矩阵的所有连通域（8邻接），并给出每个连通域的面积（邻接点的个数）和重心。
+
+每组输入包括 M+1 行，第一行输入2个整数 M (1<M<100), N (1<N<100)，其中M是矩阵的行数，N是矩阵的列数。
+第2至M+1行，每行 N 个整数，表示在矩阵N列的像素值（已二值化为 0 和 1， 连通域为 1 表示的区域）。
+
+输出 K+1 行，第一行输出连通域个数K，第2至 K+1 行，每行输出3个数，依次表示为连通域的面积值和重心的坐标值（保留2位小数点），
+按照连通域起始点顺序输出。
+e.g. Input:
+4 4
+0 1 0 0
+0 0 0 1
+0 0 0 1
+1 0 0 0
+Output:
+3
+1 1.00 0.00
+2 3.00 1.50
+1 0.00 3.00
+"""
+
+"""
+# wrong understanding
+import operator
+def fun():
+    result=[]
+    dirs=[(-1,0),(1,0),(0,-1),(0,1),(-1,-1),(1,-1),(-1,1),(1,1)]
+    for i in range(1,row-1):
+        for j in range(1,col-1):
+            cor=[]
+            for dx,dy in dirs:
+                if (num_list[i+dx][j+dy] == 1):
+                    cor.append((i+dx,j+dy))
+            # area=sum(list(num_list[i-1,j],num_list[i+1,j],
+            #               num_list[i, j - 1],num_list[i, j+1],
+            #               num_list[i - 1, j - 1],num_list[i - 1, j+1],
+            #               num_list[i + 1, j - 1],num_list[i + 1, j+1]))
+            # print("cor",cor)
+            if len(cor)==1 or all(is_connect(cor,t1) for t1 in cor):
+                x_sum=0
+                y_sum=0
+                for t in cor:
+                    x,y=t
+                    x_sum+=x
+                    y_sum+=y
+                # mid_x = round(x_sum /len(cor),2)
+                # mid_y = round(y_sum / len(cor),2)
+                mid_x = '%.2f'% (x_sum / len(cor))
+                mid_y = '%.2f'% (y_sum / len(cor))
+                result.append((len(cor),mid_y,mid_x))
+
+    print(len(result))
+    for ele in result:
+        # area,mid_x,mid_y=ele
+        print(ele[0],ele[1],ele[2])
+
+def is_connect(cor,t1):
+    x1,y1=t1
+    for t in cor:
+        if(not operator.eq(t,t1)):
+            x,y=t
+            if(x1==x or y1==y):
+                return True
+                break
+    return False
+"""
+
+def fun2():
+    count=0
+    result=[]
+    for i in range(row):
+        for j in range(col):
+            if(num_list[i][j]):
+                x_sum,y_sum,num=dfs(i,j,used,0,0,0)
+                count+=1
+                result.append((num,y_sum/num,x_sum/num))
+    print(count)
+    for res in result:
+        # print("%d %.2f %.2f" % (res[0],res[1],res[2]))
+        print("{} {:.2f} {:.2f}".format(res[0],res[1],res[2]))
+
+dirs = [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (1, -1), (-1, 1), (1, 1)]
+
+def dfs(i, j, used,x_sum, y_sum, num):
+    num_list[i][j]=0  ###### if belongs to other's adjacency, don't need to count its adjacency
+    x_sum, y_sum= x_sum + i, y_sum + j
+    num+=1
+    for ix,iy in dirs:
+        if(0<=i+ix<row and 0<=j+iy<col and num_list[i+ix][j+iy] and not used[i+ix][j+iy]):
+            used[i+ix][j+iy]=1
+            x_sum, y_sum, num=dfs(i + ix, j + iy, used,x_sum, y_sum, num)  #### or add (i+ix,y+iy) to a list
+    return x_sum, y_sum, num
+
+
+if __name__ == "__main__":
+    row,col= map(int,input().strip().split())
+    num_list=[]
+    for i in range(row):
+        num_list.append(list(map(int,input().strip().split())))
+    # print(num_list)
+    used = [[0 for j in range(col)] for i in range(row)]
+    fun2()
diff --git a/Espressif/2020_Soft/es1.py b/Espressif/2020_Soft/es1.py
@@ -0,0 +1,44 @@
+import math
+def root(n,num):
+    incre=0.005
+    i=1
+    while(i<num):
+        prod=1
+        for j in range(n): # i multiply n times
+            prod=prod*i
+        if(prod>=num):
+            n_root=i-incre
+            break
+        i+=incre
+    print(n_root)
+
+def root2(n,num):
+    n_root=math.exp(1/n * math.log(num))
+    print(n_root)
+
+def root3(n,num):
+    acc=0.001
+    # if(num>=1):
+    #     low=1
+    #     high=num
+    # else:
+    #     low=num
+    #     high=1
+    low=0
+    high=num
+    while(abs(low-high)>=10**-16):
+        mid=(low+high)/2.0
+        # prod=1
+        # for j in range(n): # mid multiply n times
+        #     prod=prod*mid
+        prod=mid**n
+        if(abs(prod-num)<=acc):
+            break
+        if(prod>=num): high=mid
+        else: low=mid
+
+    print("%.12f"%mid)
+
+if __name__ == "__main__":
+    num,n=map(int,input().strip().split())
+    root3(n,num)
diff --git a/Espressif/2020_Soft/es2.py b/Espressif/2020_Soft/es2.py
@@ -0,0 +1,141 @@
+"""
+8 7 3 6
+0 1
+1 2
+2 3
+0 3
+4 5
+5 6
+4 7
+"""
+class Graph():
+    def __init__(self,nodes,sides):
+        '''
+        nodes 表示点, list
+        sides 表示边(两个点组成的边), a list of tuple
+        '''
+        # self.sequence是字典，key是node，value是与key相连接的点(是list)
+        self.sequence = {}
+        # self.side是临时变量，主要用于保存与指定点相连接的点
+        self.side=[]
+        for node in nodes:
+            for side_tuple in sides:  ## side_tuple is a tuple
+                u,v=side_tuple
+                # 指定点与另一个点在同一个边中，则说明这个点与指定点是相连接的点，则需要将这个点放到self.side中
+                if node == u:
+                    self.side.append(v)
+                elif node == v:
+                    self.side.append(u)
+            self.sequence[node] = self.side
+            self.side=[]
+
+    # def count(self):
+    #      """
+    #      wrong method, which might contains the duplicated node
+    #      :return:
+    #      """
+    #      sides_list=[]
+    #      print(self.sequence)
+    #      combine_list=[]
+    #      temp=[]
+    #      for k, v in self.sequence.items():
+    #          combine_list=v.copy()  ######
+    #          combine_list.append(k)
+    #          flag=False
+    #          for i in range(len(sides_list)):
+    #             # if k in sides_list[i]:
+    #             #     flag=True
+    #             #     break
+    #             if(any(ele in sides_list[i] for ele in combine_list)):
+    #                 flag=True
+    #                 break
+    #          if(flag):
+    #              # temp=list(sides_list[i]).extend(combine_list) ###### temp=None
+    #              # print("temp",temp)
+    #              temp=list(sides_list[i])
+    #              temp.extend(combine_list)
+    #              print("temp",temp)
+    #              sides_list[i]=temp.copy()
+    #              print("sides_list[i]",sides_list[i])
+    #              sides_list[i]=set(sides_list[i])
+    #              print("sides_list[i]_2",sides_list[i])
+    #          else:
+    #              sides_list.append(combine_list)
+    #          # v.append(k)
+    #          # sides_list.append(v)
+    #          # if(set(v) & set(sides_list[i])!=None):
+    #          #      v+sides_list[i]
+    #          # i=+1
+    #
+    #      sides_t_list=[]
+    #      split_list=[]
+    #      for sides in sides_list:
+    #          sides_t= set(sides)
+    #          if(len(sides_t)==1):
+    #              split_list.append(sides_t)
+    #          else:
+    #              sides_t_list.append(sides_t)
+    #      print(sides_t_list)
+    #      print(split_list)
+    #      cost=2*b+b*(len(sides_t_list)+len(split_list)-1)+a*len(sides_t_list)
+    #      return cost
+
+    def DFS(self, node0):
+        # queue本质上是栈，用来存放需要进行遍历的数据
+        # order里面存放的是具体的访问路径
+        queue, order = [], []
+        # 首先将初始遍历的节点放到queue中，表示将要从这个点开始遍历
+        queue.append(node0)
+        while queue:
+            # 从queue中pop出点v，然后从v点开始遍历了，所以可以将这个点pop出，然后将其放入order中
+            # 这里才是最有用的地方，pop()表示弹出栈顶，由于下面的for循环不断的访问子节点，并将子节点压入堆栈，
+            # 也就保证了每次的栈顶弹出的顺序是下面的节点
+            v = queue.pop()  #####LIFO
+            order.append(v)
+            # 这里开始遍历v的子节点
+            for w in self.sequence[v]:  #####
+                # w既不属于queue也不属于order，意味着这个点没被访问过，所以将其放到queue中，然后后续进行访问
+                if w not in order and w not in queue:
+                    queue.append(w)
+        return order
+
+if __name__ == "__main__":
+    n,m,a,b = map(int,input().strip().split())
+    nodes = [i for i in range(n)]
+    # print(nodes)
+    sides=[]
+    for i in range(m):
+        t= set(map(int,input().strip().split()))
+        sides.append(t)
+    # print(sides)
+
+    g=Graph(nodes,sides)
+    # cost=g.count()
+    # print(cost)
+    side_list=[]
+    side_list_all=[]
+    for node in nodes:
+        side_list=g.DFS(node)
+        # print(side_list)
+        side_list_all.append(tuple(sorted(side_list)))
+
+    # print(side_list_all)
+    cnt=1
+    dict_con={}
+    for i in range(len(side_list_all)-1):
+        if(side_list_all[i] not in dict_con):
+            dict_con.update({side_list_all[i]:1})
+        else:
+            dict_con[side_list_all[i]]+=1
+    cnt=len(dict_con.keys())
+    print(len(side_list_all),cnt)
+    cost = 2 * b + b * (cnt-1) + a * cnt
+    print(cost)
+
+
+
+
+
+
+
+
diff --git a/Newcoder/nq2.py b/Newcoder/nq2.py
@@ -55,5 +55,5 @@ def fun2(values):
 if __name__ == "__main__":
     n = int(sys.stdin.readline().strip())
     line = sys.stdin.readline().strip()
-    values = list(map(int, line.split()))
+    values = list(map(float, line.split())) ###float
     fun(values)
diff --git a/Newcoder/nq3.py b/Newcoder/nq3.py
@@ -5,11 +5,11 @@
 Output: The number of longest increasing subsequence
 In: 6
 7 2 3 1 5 6
-Output: 5
+Output: 5 - {2 3 1 5 6}
 
 In: 5
 10 3 10 5 7
-Output: 4
+Output: 4 - {3 10 5 7}
 """
 import sys
 def fun(values):
