LeetCode——788.旋转数字

通过万岁！！！

• 题目：这个题目我读了好久。这个题目的意思是0-9中只有2、5、6、9是好数，因为他们寻转180度以后还是一个数，但是不等于自己。这个就是好数，好数的定义就是每个位上旋转180度以后的数，是一个有效的数，并且不等于自己。0、1、8单纯反转不是好数，但是12反转以后变成15，是好数。3、4、7不管怎么样都不是好数。所以可以总结为：只要包含3、4、7就不是，只包含0、1、8也不是。然后其他的就都是了。
• 思路：我用的动态规划。定以一个数组，记录个位数之前的那些是不是好数，-1表示不好的数，也就是包含了3、4、7；0表示无所谓的数，也就是只包含0、1、8；然后1就是好数了。当前这个数的好数判断就是判断前面的（个位数之前的），然后再判断自己（个位数）。然后还需要然后就是for循环，从1-n开始判断，如果i这个是，那么就将结果++即可，并且在数组中进行标记。
• 技巧：动态规划
• 代码优化：我觉得这个题目还挺有意思的，我写了一个版本的代码，比较复杂，然后发现可以优化的地方有好多。然后下面的代码我贴了多个版本。

java代码——版本一

class Solution {
    public int rotatedDigits(int n) {
        int[] flag = new int[n + 1];
        if (n < 2) {
            return 0;
        } else if (n < 5) {
            return 1;
        } else if (n < 6) {
            return 2;
        } else if (n < 9) {
            return 3;
        } else if (n < 11) {
            return 4;
        }
        int res = 4;
        flag[0] = 0;
        flag[1] = 0;
        flag[2] = 1;
        flag[3] = -1;
        flag[4] = -1;
        flag[5] = 1;
        flag[6] = 1;
        flag[7] = -1;
        flag[8] = 0;
        flag[9] = 1;
        flag[10] = 0;
        int temp;
        for (int i = 11; i <= n; i++) {
            temp = i % 10;
            if ((temp == 2 || temp == 5 || temp == 6 || temp == 9) && flag[i / 10] != -1) {// 个位是，之前的只要不是绝对不是
                res++;
                flag[i] = 1;
            } else if ((temp == 0 || temp == 8 || temp == 1) && flag[i / 10] == 1) {// 个位无所谓，之前的是
                res++;
                flag[i] = 1;
            } else if ((temp == 0 || temp == 8 || temp == 1) && flag[i / 10] == 0) {// 个位无所谓，之前的也是无所谓，那么这个还是无所谓
                flag[i] = 0;
            } else {
                flag[i] = -1;
            }
        }
        return res;
    }
}

java代码——版本二，简化if判断

class Solution {
    public int rotatedDigits(int n) {
        int[] flag = new int[n + 1];
        if (n < 2) {
            return 0;
        } else if (n < 5) {
            return 1;
        } else if (n < 6) {
            return 2;
        } else if (n < 9) {
            return 3;
        } else if (n < 11) {
            return 4;
        }
        int res = 4;
        flag[0] = 0;
        flag[1] = 0;
        flag[2] = 1;
        flag[3] = -1;
        flag[4] = -1;
        flag[5] = 1;
        flag[6] = 1;
        flag[7] = -1;
        flag[8] = 0;
        flag[9] = 1;
        flag[10] = 0;
        int temp;
        for (int i = 11; i <= n; i++) {
            temp = i % 10;
            if (flag[temp] == 1 && flag[i / 10] != -1) {// 个位是，之前的只要不是绝对不是
                res++;
                flag[i] = 1;
            } else if (flag[temp] == 0 && flag[i / 10] == 1) {// 个位无所谓，之前的是
                res++;
                flag[i] = 1;
            } else if (flag[temp] == 0 && flag[i / 10] == 0) {// 个位无所谓，之前的也是无所谓，那么这个还是无所谓
                flag[i] = 0;
            } else {
                flag[i] = -1;
            }
        }
        return res;
    }
}

java代码——版本三，将两种情况进行整合

class Solution {
    public int rotatedDigits(int n) {
        int[] flag = new int[n + 1];
        if (n < 2) {
            return 0;
        } else if (n < 5) {
            return 1;
        } else if (n < 6) {
            return 2;
        } else if (n < 9) {
            return 3;
        } else if (n < 11) {
            return 4;
        }
        int res = 4;
        flag[0] = 0;
        flag[1] = 0;
        flag[2] = 1;
        flag[3] = -1;
        flag[4] = -1;
        flag[5] = 1;
        flag[6] = 1;
        flag[7] = -1;
        flag[8] = 0;
        flag[9] = 1;
        flag[10] = 0;
        int temp;
        for (int i = 11; i <= n; i++) {
            temp = i % 10;
            if (flag[temp] == 1 && flag[i / 10] != -1) {// 个位是，之前的只要不是绝对不是
                res++;
                flag[i] = 1;
            } else if (flag[temp] == 0 && flag[i / 10] != -1) {// 个位无所谓，之前的不是包含3、4、7的
                res += flag[i / 10];
                flag[i] = flag[i / 10];
            } else {
                flag[i] = -1;
            }
        }
        return res;
    }
}

• 总结：题目还是挺有意思的，我看了大佬的题解，都是n*logn，但是我这个时间复杂度好像是n。