算法进修Day-23

算法进修Day-23

45. 跳跃游戏2

难度：中等
题目要求：
给定一个长度为n的0索引整数数组nums。初始位置为nums[0]。

每个元素nums[i]表示从索引i向前跳转的最大长度。换句话说，如果你在nums[i]处，你可以跳转到任意nums[i + j]处：

• 0 <= j <= nums[i]
• i + j < n

返回到达nums[n -1]的最小跳跃次数。生成的测试用例可以到达nums[n -1]。

示例1：

输入：nums = [2,3,1,1,4]
输出：2

示例2：

输入：nums = [2,3,0,1,4]
输出：2

题解：

使用贪心算法计算到达下标 $n-1$ 的最小跳跃次数

用 $currentJumps$ 表示当前跳跃次数，用 $currentMaxPosition$ 和 $nextMaxPosition$ 分别表示跳跃次数 $currentJumps$ 能够到达的最远距离和跳跃次数 $currentJumps+1$ 可以到达的最远距离，初始时 $currentJumps=0，currentMaxPosition=0，nextMaxPosition=0$

从左到右遍历数组 $nums$，对每个 $0\le i<n$，执行如下操作：

• 如果 $i>currentMaxPosition$，则下标 $i$ 超出跳跃次数 $currentJumps$ 可以到达的下标，因此到达下标 $i$ 的最小跳跃次数是 $currentJumps+1$，需要更新 $currentJumps$ 和 $currentMaxPosition$ 的值；将 $currentJumps$ 的值加1，将 $currentMaxPosition$ 的值更新为 $nextMaxPosition$。如果 $i\le currentMaxPosition$，则不执行更新操作
• 从下标 $i$ 可以到达的最大下标为 $i+nums[i]$。由于跳跃次数 $currentJumps$ 可以到达下标 $i$，因此跳跃次数 $currentJumps+1$ 可以到达下标 $i+nums[i]$，跳跃次数 $currentJumps+1$ 可以到达的最大下标不小于 $i+nums[i]$，用 $i+nums[i]$更新 $nextMaxPosition$ 的值

遍历结束之后，$currentJumps$ 即为到达下标 $n-1$ 的最小跳跃次数

想法代码

class Solution
{
    public static void Main(String[] args)
    {
        int[] nums = { 2, 3, 1, 1, 4 };
        Solution solution = new Solution();
        int res = solution.Jump(nums);
        Console.WriteLine(res);
    }

    public int Jump(int[] nums)
    {
        int currentJumps = 0;
        int currentMaxPosition = 0;
        int nextMaxPosition = 0;
        int len = nums.Length;
        for (int i = 0; i < len; i++)
        {
            if (i > currentMaxPosition)
            {
                currentJumps++;
                currentMaxPosition = nextMaxPosition;
            }
            nextMaxPosition = Math.Max(nextMaxPosition, nums[i] + i);
        }
        return currentJumps;
    }
}

46. 全排列

难度：中等
题目要求：
给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。

示例1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例3：

输入：nums = [1]
输出：[[1]]

题解：

用 $n$ 表示数组 $nums$ 的长度，创建列表 $temp$ 用于存储当前排列，将数组 $nums$ 中每个元素依次加入 $temp$，然后根据 $temp$ 生成全排列

为了得到数组 $nums$ 的全排列，需要依次确定排列中的每个位置的元素，可以通过交换 $temp$ 中的元素实现，对于 $0\le index<n$，按照下标 $index$ 从小到大的顺序依次确定每个 $temp[index]$ 的值，即能得到一个排列

• 当 $index=0$，可以将 $temp[0]$ 和任意一个元素交换（包括和自身交换），经过一次交换之后即可确定当前排列中的 $temp[0]$ 的值
• 当 $index>0$，如果当前排列中 $temp[0]$ 到 $temp[index-1]$ 的值都已经确定，则可以将 $temp[index]$ 和任意一个下标大于等于 $index$ 的元素交换，经过一次交换之后即可确定当前排列中 $temp[index]$ 的值

通过上述分析，可以利用回溯法，步骤如下：

• 如果 $index=n$，则当前排列中的所有元素都已经确定，则将当前排列添加到结果列表中
• 如果 $index<n$，则对于每一个 $index\le i<n$，执行如下操作：
  • 将 $temp[index]$ 和 $temp[i]$ 的值交换，然后将 $index+1$ 作为当前下标继续搜索
  • 将 $temp[index]$ 和 $temp[i]$ 的值再次交换，恢复到交换之前的状态

当每个下标对应的所有可能的值都遍历结束之后，就可以得到数组 $nums$ 的全排列

想法代码

class Solution
{
    IList> permutations = new List>();
    IList temp = new List();
    int n;

    public static void Main(String[] args)
    {
        int[] nums = { 1, 2, 3 };
        Solution solution = new Solution();
        IList> res = solution.Permute(nums);
        foreach (var a in res)
        {
            foreach (var b in a)
            {
                Console.Write(b + " ");
            }
            Console.WriteLine();
        }
    }

    public IList> Permute(int[] nums)
    {
        foreach (int i in nums)
        {
            temp.Add(i);
        }
        n = nums.Length;
        BackTrack(0);
        return permutations;
    }

    public void BackTrack(int index)
    {
        if (index == n)
        {
            permutations.Add(new List(temp));
        }
        else
        {
            for (int i = index; i < n; i++)
            {
                Swap(temp,index,i);
                BackTrack(index+1);
                Swap(temp, index, i);
            }
        }
    }

    public void Swap(IList temp, int index1, int index2)
    {
        int cur = temp[index1];
        temp[index1] = temp[index2];
        temp[index2] = cur;
    }
}