Go刷剑指offer

前言

这个是我刷题碰到的一些自己不会的题，然后看看大佬们的题解来做的，这里需要特别感谢@Krahets大佬，有啥不懂，看看大佬的题解豁然开朗。下面的很多截图都是从大佬那里来的。

剑指 Offer 45. 把数组排成最小的数

// 实现Sort接口进行排序，这里的string可以实现为自己的数据结构
type MySlice []string 

func (s MySlice) Len() int {
   
    return len(s)
}

func (s MySlice) Swap(i, j int) {
   
    s[i], s[j] = s[j], s[i]
}

func (s MySlice) Less(i, j int) bool {
   
    tmp1 := s[i] + s[j]
    tmp2 := s[j] + s[i]
    return compare(tmp1, tmp2)
}

func compare(s1, s2 string) bool{
   
    if s1 < s2 {
   
        return true
    }
    return false
}

func minNumber(nums []int) string {
   
    var arr MySlice
    for _, num := range nums {
   
        arr = append(arr, strconv.Itoa(num))
    }
    // fmt.Println(arr)
    sort.Sort(arr)
    res := ""
    for _, a := range arr {
   
        res += a
    }
    // fmt.Println(compare("303","330"))
    return res
}

// 调用slice进行重新排序
func minNumber(nums []int) string {
   
    var strNums []string
    for _, num := range nums {
   
        strNums = append(strNums, strconv.Itoa(num))
    }
    sort.Slice(strNums, func(i, j int)bool{
   
        if strNums[i] + strNums[j] < strNums[j] + strNums[i] {
   
            return true
        }
        return false
    })
    return strings.Join(strNums, "")
}

剑指 Offer 68 - II. 二叉树的最近公共祖先

class Solution {
public:
    TreeNode* res;
    bool helper(TreeNode* root, TreeNode* p, TreeNode* q)  {
        if (!root) {
            return false;
        }
        bool left = helper(root->left, p, q);
        bool right = helper(root->right, p, q);
        if ( (left && right) || ((root == p || root == q) && (left || right)) ) {
            res = root;
        }
        return left || right || root == p || root == q;

    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        helper(root, p, q);
        return res;
    }
};

剑指 Offer 13. 机器人的运动范围

这里就是一个比较典型的图搜索算法，使用的方法有两种，dfs和bfs, 其中dfs就是一个递归程序，而bfs则是需要利用队列来实现。同时，需要注意的是，这题是一个连通图的模型，不能利用循环遍历，要不然会增加不可达的可行解。（需要一个辅助数组来确定是否已经遍历过了）

func movingCount(m int, n int, k int) int {
   
    if m == 0 || n == 0 {
   
        return 0
    }
    res := 0
    vis := make([][]bool, m)
    able := make([][]bool, m)
    for i:=0; i<m; i++ {
   
        vis[i] = make([]bool, n)
        able[i] = make([]bool, n)
    }
    del := [][]int{
   {
   0,1},{
   1,0}}
    var dfs func(i, j, m, n int)
    var bfs func(i, j, m, n int)

    dfs = func(i, j, m, n int) {
   
        if vis[i][j] {
   
            return
        }
        vis[i][j] = true
        if numSum(i, j) <= k {
   
            res++
        } else {
   
            return
        }
        for d