近日LeetCode算法（记录）

近日LeetCode算法

前言：最近刷了好多leetcode算法题，大家知道，程序=数据结构+算法，由此可见，算法真的是很重要的呢。闲话少谈，切入正题，来看看小编觉得有点意思的5题算法题吧...

1. LeetCode 73：矩阵置零难度等级：中等

题目

给定一个 m x n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。

示例

解题思路

这是一个二维数组，我们只需要遍历一遍这个二维数组，把元素为0的那个位置所在的行与列分别标记起来，可以放在一个HashSet中，我们都知道，Set是一种无序不重复的集合，而List是有序可重复的，因此在这里小编选用两个Set来存储标记好的下标索引，遍历完得到这两个HashSet后，从HashSet中取得这些所有为0行列的索引后，我们就可以把原二维数组的某一行，某一列全部置为0即可。
值得注意的是，我们不可以一边标记一边置零，因为这样操作会影响结果，所以我们只可以遍历一遍，用来标记，再遍历一遍。用来置零。

图解

代码实现

package com.hx.leetcode.L_201910;

import java.util.HashSet;

import java.util.Set;

/**

 * @author: wenhx

 * @date: Created in 2019/10/1 23:03

 * @description: LeetCode_73：矩阵置零

 * @level: middle

 * @status: finish

 * @version: $1.0

 */

public class LeetCode_73 {

    /**

     * 将矩阵中所有0的行列置为0

     */

    public void setZeroes(int[][] matrix) {

        // 定义两个集合用来存放为0所有的下标

        Set<Integer> set1 = new HashSet<>();

        Set<Integer> set2 = new HashSet<>();

        for (int i = 0; i < matrix.length; i++) {

            for (int j = 0; j < matrix[0].length; j++) {

                if (matrix[i][j] == 0) {

                    set1.add(i);

                    set2.add(j);

                }

            }

        }

        // 行置为0

        for (Integer a : set1

        ) {

            for (int j = 0; j < matrix[0].length; j++) {

                matrix[a][j] = 0;

            }

        }

        // 列置为0

        for (Integer b : set2

        ) {

            for (int i = 0; i < matrix.length; i++) {

                matrix[i][b] = 0;

            }

        }

    }

    /**

     * 主方法：用来测试算法

     * @param args

     */

    public static void main(String[] args) {

        LeetCode_73 leetCode_73 = new LeetCode_73();

        int[][] matrix = {{0,1,2,0}, {3,4,5,2}, {1,3,1,5}};

        leetCode_73.setZeroes(matrix);

        for (int i = 0; i < matrix.length; i++) {

            for (int j = 0; j < matrix[0].length; j++) {

                System.out.print(matrix[i][j] + " ");

            }

        }

    }

}

2. LeetCode 495：提莫攻击难度等级：中等

题目

在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄，他的攻击可以让敌方英雄艾希（寒冰射手）进入中毒状态。现在，给出提莫对艾希的攻击时间序列和提莫攻击的中毒持续时间，你需要输出艾希的中毒状态总时长。

你可以认为提莫在给定的时间点进行攻击，并立即使艾希处于中毒状态。

示例

解题思路

这条题目的入参是一个数组，用来记录提莫攻击的时间点，还有一个中毒的持续时间。我们可以先处理一下这个关于时间点的数组，相邻时间点的差值就是时间间隔，因此可以推出一个关于时间间隔的数组。假设时间点数组长度为n，那么时间间隔数组的长度就是n-1。得到这个时间间隔数组之后，再来处理中毒时间就很容易了
我们先有一个记录总中毒时间的变量，然后遍历时间间隔数组，假如间隔值大于或者等于中毒持续时间，则总中毒时间加单次中毒持续的时间；假如间隔值小于中毒持续时间，则加上间隔值即可。

图解

代码实现

package com.hx.leetcode.L_201910;

/**

 * @author: wenhx

 * @date: Created in 2019/10/5 12:03

 * @description: LeetCode_495：提莫攻击

 * @level: middle

 * @status: finish

 * @version: $1.0

 */

public class LeetCode_495 {

    /**

     * 计算中毒状态总时长

     */

    public int findPoisonedDuration(int[] timeSeries, int duration) {

        int sum = 0;

        if (timeSeries.length == 0) {

            return 0;

        }

        if (timeSeries.length == 1) {

            return duration;

        }

        // n个时间点有n-1个时间间隔

        int[] timeInterval = new int[timeSeries.length - 1];

        for (int i = 0; i < timeInterval.length; i++) {

            timeInterval[i] = timeSeries[i + 1] - timeSeries[i];

        }

        // 根据时间间隔来判断中毒秒数

        for (int i = 0; i < timeInterval.length; i++) {

            if (timeInterval[i] >= duration) {

                sum += duration;

            } else {

                sum += timeInterval[i];

            }

        }

        return sum + duration;

    }

    public static void main(String[] args) {

        LeetCode_495 leetCode_495 = new LeetCode_495();

        int[] timeSeries = {1, 4};

        int duration = 2;

        System.out.println("中毒状态总时长为：" + leetCode_495.findPoisonedDuration(timeSeries, duration));

    }

}

3. LeetCode 41：缺失的第一个正数难度等级：困难

题目

给定一个未排序的整数数组，找出其中没有出现的最小的正整数。

aaarticlea/png;base64,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" alt="" />

解题思路

求缺失的第一个正数，那个先定义一个变量j来记录，j从1开始。
先对原数组进行排序，然后遍历，如果遍历元素大于j，那么找到缺失的第一个正数；如果遍历元素大于0并且小于j，那么j自增；这里还要判断遍历元素是否有重复，因此我们可以定义一个临时变量temp来记录上一个遍历元素的值，当连续相等时则continue，j不自增。

图解

代码实现

package com.hx.leetcode.L_201909;



import java.util.Arrays;



/**

 * @author: wenhx

 * @date: Created in 2019/9/26 09:23

 * @description: LeetCode_41：缺失的第一个正数

 * @level: hard

 * @status: finish

 * @version: $1.0

 */

public class LeetCode_41 {



    /**

     * 计算缺失的第一个正数

     */

    public int firstMissingPositive(int[] nums) {

        // 对数组进行排序

        Arrays.sort(nums);

        // 定义一个从1开始自增的正数

        int j = 1;

        // 定义一个临时变量，用来判断相邻值是否相同

        int temp = 0;

        for (int i = 0; i < nums.length; i++) {

            // 当数组中某值大于自增j时

            if (nums[i] > j) {

                return j;

            }

            // 当数组中某值大于0并且不大于j时

            else if (nums[i] > 0 && nums[i] <= j) {

                // 数组中连续一样

                if (temp == nums[i]) {

                    continue;

                }

                j++;

            } else {

                continue;

            }

            // 更新临时变量

            temp = nums[i];

        }

        return j;

    }



    public static void main(String[] args) {



        LeetCode_41 leetCode_41 = new LeetCode_41();

        int[] nums = {1, 2, 0};

        System.out.println("缺失的第一个正数为：" + leetCode_41.firstMissingPositive(nums));

    }



}

4. LeetCode 535：TinyURL的加密与解密难度等级：中等

题目

TinyURL是一种URL简化服务。要求：设计一个 TinyURL 的加密 encode 和解密 decode 的方法。你的加密和解密算法如何设计和运作是没有限制的，你只需要保证一个URL可以被加密成一个TinyURL，并且这个TinyURL可以用解密方法恢复成原本的URL。

示例

当你输入一个URL https://leetcode.com/problems/design-tinyurl 时

它将返回一个简化的URL http://tinyurl.com/4e9iAk.

解题思路

这条题目主要是模拟对url的加密与解密，通过HashMap可以很好的处理加密前与加密后的映射。
加密后的url前缀格式有“http://tinyurl.com/”，问题是后面的6位随机码如何产生呢？很简单，自己写一个算法呗！看下列代码，可复用喔~

图解

代码实现

package com.hx.leetcode.L_201910;



import java.util.HashMap;

import java.util.Random;



/**

 * @author: wenhx

 * @date: Created in 2019/10/7 11:44

 * @description: LeetCode_535：TinyURL的加密与解密

 * @level: middle

 * @status: finish

 * @version: $1.0

 */

public class LeetCode_535 {



    private HashMap hashMap = new HashMap<String, String>();



    /**

     * 加密：将一个长的url转换为一个短的url

     * @param longUrl

     * @return

     */

    public String encode(String longUrl) {

        String keyString = "http://tinyurl.com/" + getRandomString(6);

        hashMap.put(keyString, longUrl);

        return keyString;

    }



    /**

     * 解密：将一个短的url转换为一个长的url

     * @param shortUrl

     * @return

     */

    public String decode(String shortUrl) {

        return (String) hashMap.get(shortUrl);

    }



    /**

     * 自定义方法：产生6位数的字符串随机码

     * @param length

     * @return

     */

    public static String getRandomString(int length) {

        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        Random random = new Random();

        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < length; i++) {

            int number = random.nextInt(62);

            sb.append(str.charAt(number));

        }

        return sb.toString();

    }



    /**

     * 主方法：用来测试一下

     * @param args

     */

    public static void main(String[] args) {

        LeetCode_535 codec = new LeetCode_535();

        String longUrl = "https://leetcode.com/problems/design-tinyurl";

        String shortUrl = codec.encode(longUrl);

        System.out.println("加密后的url是：" + shortUrl);

        System.out.println("解密后的url是：" + codec.decode(shortUrl));

    }

}

5. LeetCode 20：有效的括号难度等级：简单

题目

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例

解题思路

这里括号的匹配，用栈可以很好地解决这个问题。我们都知道，栈是一个后进先出的数据结构，将一个具有()[]{}的字符串从后面开始，一个一个地压入栈中，压第一个，然后再拿字符串中相对最后一个括号与栈中栈顶元素匹配，例如 ")"与"("匹配，"]"与"["匹配，"}"与"{"匹配。这里值得注意的是，栈顶的括号必须是右括号，而字符串尾部的括号必须是左括号。

图解

代码实现

package com.hx.leetcode.L_Before;



import java.util.Stack;



/**

 * @author: wenhx

 * @date: Created in 2019/9/25 10:58 （之前）

 * @description: LeetCode_20：有效的括号

 * @level: simple

 * @status: finish

 * @version: $1.0

 */

public class LeetCode_20 {



    /**

     * 计算是否有效的括号

     */

    public boolean isValid(String s) {

        Stack<String> m = new Stack<>();

        while (!s.isEmpty()) {

            if (m.empty()) {

                m.push(s.substring(s.length() - 1));

            } else {

                if (m.peek().equals(")") && s.substring(s.length() - 1).equals("(")

                    || m.peek().equals("]") && s.substring(s.length() - 1).equals("[")

                    || m.peek().equals("}") && s.substring(s.length() - 1).equals("{")) {

                    m.pop();

                } else {

                    m.push(s.substring(s.length() - 1));

                }

            }

            s = s.substring(0, s.length() - 1);

        }

        if (m.empty()) {

            return true;

        } else {

            return false;

        }

    }



    public static void main(String[] args) {



        LeetCode_20 leetCode_20 = new LeetCode_20();

        String s = "{[]}()";

        System.out.println(leetCode_20.isValid(s));

    }

}

好啦，今天就先到这啦，以上算法纯属小编个人想法，如有疑惑可以私信或者留言，蟹蟹大家。一起谈论，一起进步。

小伙伴们后续有时间小编会经常跟新的嘿嘿...

后续

个人博客地址：https://www.cnblogs.com/q964024886/

GitHub地址：https://github.com/wenhaixiong

微信公众号：