《12.16-12.22 Leetcode》

1. 罗马数字转整数

题目描述：
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

代码：

package leetcode;

import java.util.HashMap;
import java.util.Map;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-20 14:18
 * @desc
 */
public class t13 {
    public static int romanToInt(String s) {
        Map<String, Integer> map = new HashMap<>();
        map.put("I", 1);
        map.put("IV", 4);
        map.put("V", 5);
        map.put("IX", 9);
        map.put("X", 10);
        map.put("XL", 40);
        map.put("L", 50);
        map.put("XC", 90);
        map.put("C", 100);
        map.put("CD", 400);
        map.put("D", 500);
        map.put("CM", 900);
        map.put("M", 1000);

        int ans = 0;
        for (int i = 0; i < s.length(); ) {
            if (i + 1 < s.length() && map.containsKey(s.substring(i, i + 2))) {
                ans += map.get(s.substring(i, i + 2));
                i += 2;
            } else {
                ans += map.get(s.substring(i, i + 1));
                i++;
            }
        }
        return ans;
    }

    public static void main(String[] args) {
        String str = "III";
        System.out.println(romanToInt(str));
    }
}

2. 最长公共前缀

题目描述：
编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:

输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
说明:

所有输入只包含小写字母 a-z 。

代码：

package leetcode;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-20 14:41
 * @desc
 */
public class t14 {

    public static String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) {
            return "";
        }
        String ans = strs[0];
        for (int i = 1; i < strs.length; i++) {
            int j = 0;
            for (; j < ans.length() && j < strs[i].length(); j++) {
                if (ans.charAt(j) != strs[i].charAt(j)) {
                    break;
                }
            }
            ans = ans.substring(0, j);
            if (ans.equals("")) {
                return ans;
            }
        }
        return ans;
    }

    public static void main(String[] args) {
        String[] strs = {"flower", "flow", "floight"};
        System.out.println(longestCommonPrefix(strs));
    }
}

3. 字符串匹配

题目描述：
实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = “hello”, needle = “ll”
输出: 2
示例 2:

输入: haystack = “aaaaa”, needle = “bba”
输出: -1

代码：

package leetcode;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-20 15:20
 * @desc 字符串匹配，kmp算法
 */
public class t28 {

    /**
     * 字符串匹配
     *
     * @param haystack
     * @param needle
     * @return
     */
    public static int strStr(String haystack, String needle) {
        if (needle == null || "".equals(needle)) {
            return 0;
        }
        if (haystack.length() < needle.length()) {
            return -1;
        }

        return kmp(haystack, needle);
    }

    /**
     * kmp字符串匹配算法
     *
     * @param str1
     * @param str2
     * @return
     */
    public static int kmp(String str1, String str2) {
        char[] ch1 = str1.toCharArray();
        char[] ch2 = str2.toCharArray();
        int i = 0;
        int j = 0;
        int[] next = next(ch2);
        while (i < ch1.length && j < ch2.length) {
            if (ch1[i] == ch2[j]) {
                i++;
                j++;
            } else {
                if (next[j] == -1) {
                    i++;
                } else {
                    j = next[j];
                }
            }
        }
        return j == ch2.length ? i - j : -1;
    }

    /**
     * 获取next数组
     *
     * @param ch
     * @return
     */
    public static int[] next(char[] ch) {
        int next[] = new int[ch.length];
        next[0] = -1;
        if (ch.length == 1) {
            return next;
        }
        next[1] = 0;
        int pos = 2;
        int cn = 0;
        while (pos < next.length) {
            if (ch[pos - 1] == ch[cn]) {
                next[pos++] = ++cn;
            } else if (cn > 0) {
                cn = next[cn];
            } else {
                next[pos++] = 0;
            }
        }
        return next;
    }

    public static void main(String[] args) {
        String str1 = "mississippi";
        String str2 = "issipi";
        System.out.println(strStr(str1, str2));
    }
}

4. 搜索插入位置

题目描述:
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。

代码：

package leetcode;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-20 17:14
 * @desc
 */
public class t35 {
    /**
     * 遇到排序问题，最优解一般都是二分查找
     *
     * @param nums
     * @param target
     * @return
     */
    public static int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }

    public static void main(String[] args) {

        int[] arr = {4, 6, 8, 9, 11};
        int target = 7;
        System.out.println(searchInsert(arr, target));
    }
}

5. 报数

题目描述：
报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：

1. 1
   

2. 11
   

3. 21
   

4. 1211
   

5. 111221
   

1 被读作 “one 1” (“一个一”) , 即 11。
11 被读作 “two 1s” (“两个一”）, 即 21。
21 被读作 “one 2”, “one 1” （“一个二” , “一个一”) , 即 1211。

给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。

注意：整数顺序将表示为一个字符串。

代码：

package leetcode;


/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-20 17:59
 * @desc
 */
public class t38 {
    public static String countAndSay(int n) {
        String str, res;
        res = "1";
        for (int i = 1; i < n; i++) {
            str = res;
            res = "";
            for (int j = 0; j < str.length(); ) {
                int c = 0, k = j;
                while (k < str.length() && str.charAt(k) == str.charAt(j)) {
                    k++;
                    c++;
                }
                res += c + String.valueOf(str.charAt(j));
                j = k;
            }
        }
        return res;
    }

    public static void main(String[] args) {
        System.out.println(countAndSay(4));
    }
}