每日编程（39）

题目：转置矩阵

题目描述：
给定一个矩阵 A， 返回 A 的转置矩阵。

矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。

示例 1：

输入：[[1,2,3],[4,5,6],[7,8,9]]
输出：[[1,4,7],[2,5,8],[3,6,9]]
示例 2：

输入：[[1,2,3],[4,5,6]]
输出：[[1,4],[2,5],[3,6]]

分析：这个题很明显直接反过来遍历就好，就是利用res[i][j]=A[j][i],
代码：

func transpose(A [][]int) [][]int {
    n1:=len(A)
    n2:=len(A[0])
    res:=[][]int{}
    for i:=0;i<n2;i++{
        arr:=[]int{}
        for j:=0;j<n1;j++{
            arr=append(arr,A[j][i])
        }
        res=append(res,arr)
    }
    return res
}

题目：865. 具有所有最深结点的最小子树

题目描述：
给定一个根为 root 的二叉树，每个结点的深度是它到根的最短距离。

如果一个结点在整个树的任意结点之间具有最大的深度，则该结点是最深的。

一个结点的子树是该结点加上它的所有后代的集合。

返回能满足“以该结点为根的子树中包含所有最深的结点”这一条件的具有最大深度的结点。

示例：

输入：[3,5,1,6,2,0,8,null,null,7,4]
输出：[2,7,4]
解释：

我们返回值为 2 的结点，在图中用黄色标记。
在图中用蓝色标记的是树的最深的结点。
输入 “[3, 5, 1, 6, 2, 0, 8, null, null, 7, 4]” 是对给定的树的序列化表述。
输出 “[2, 7, 4]” 是对根结点的值为 2 的子树的序列化表述。
输入和输出都具有 TreeNode 类型。

提示：

树中结点的数量介于 1 和 500 之间。
每个结点的值都是独一无二的。

分析：我没用递归，用了一个辅助空间，当一个节点的左右两边深度一样时，就返回这个节点，当左边大于右边，就说明在左子树中，反之就在右子树中，只要利用一个辅助空间，记录当前节点就好

代码：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func subtreeWithAllDeepest(root *TreeNode) *TreeNode {
    if root==nil{
        return root
    }
    res:=[]*TreeNode{}
    res=append(res,root)
    for len(res)!=0{
        cur:=res[len(res)-1]
        if Deap(cur.Left)==Deap(cur.Right){
            return cur
        }else if Deap(cur.Left)>Deap(cur.Right){
            res=res[:len(res)-1]
            res=append(res,cur.Left)
        }else{
            res=res[:len(res)-1]
            res=append(res,cur.Right)
        }
        
    }
    return root
}
func Deap(root *TreeNode)int{
    if root==nil{
        return 0
    }
    l:=Deap(root.Left)
    r:=Deap(root.Right)
    return max(l,r)+1
}
func max(l,r int)int{
    if l>r{
        return l
    }
    return r
}

题目：回文素数

题目描述：
求出大于或等于 N 的最小回文素数。

回顾一下，如果一个数大于 1，且其因数只有 1 和它自身，那么这个数是素数。

例如，2，3，5，7，11 以及 13 是素数。

回顾一下，如果一个数从左往右读与从右往左读是一样的，那么这个数是回文数。

例如，12321 是回文数。

示例 1：

输入：6
输出：7
示例 2：

输入：8
输出：11
示例 3：

输入：13
输出：101

分析：这个题就属于那种，直接求肯定会超时的，所以肯定需要优化，本人也没想出来，借鉴了别人的方法，当一数的长度是偶数，不是11时，肯定不会满足，为什么呢，还不太清楚。

代码：

func primePalindrome(N int) int {
          if N<=2{
          	return 2
		  }
		  if N%2==0{
		  	N++
		  }
		  i:=N
		  for i>=N{
		  	str:=strconv.Itoa(i)

		  	if len(str)%2==0 && i!=11{
		  		i=1
		  		for j:=0;j<len(str);j++{
		  			i*=10
				}
				i=i+1

			}else{

				if prime(i){

					if primePalind(i){

						return i
					}
				}
				i+=2
			}
		  }
		  return 0
}
func prime(N int)bool {
	if N == 1 {
		return true
	}
	n:=N%10
	if n==2 || n==4 || n==0 || n==6 || n==8{
		return false
	}
    for i := 2; i <=int(math.Sqrt(float64(N)));i++{
		if N%i==0{
			return false
		}
	}
	return true
}
func primePalind(N int)bool{
	str:=strconv.Itoa(N)
	n:=len(str)
	i:=0
	j:=n-1
	for i<=j{
		if str[i]!=str[j]{
			return false
		}
		i++
		j--
	}
	return true

}