关于字节面试过程不会的算法题总结

这个题目拿到手，我想到的就是把它转为String，然后对string用默认的字典序排序算法，显然忽视了当n取极限值10^9时带来的内存问题。

一开始的解法：

class Solution {
    public int findKthNumber(int n, int k) {
        ArrayList<String> list = new ArrayList<>();
        for(int i = 1; i<=n; i++){
            list.add(String.valueOf(i));
        }
        Collections.sort(list, (a, b)->{
            return a.compareTo(b);
        });
        return Integer.valueOf(list.get(k-1));
    }
}

显然：

类似于二叉树前序遍历：

class Solution {
    public int findKthNumber(int n, int k) {
        long cur = 1;
        k -= 1;

        while(k > 0){
            int nodes = getNodes(n, cur);
            if(k >= nodes){
                k -= nodes;
                cur++;      //go right
            }else{
                k -= 1;
                cur *= 10;  //go down
            }
        }

        return (int)cur;
    }

    private int getNodes(int n, long cur){
        long next = cur + 1;
        long totalNodes = 0;
        
        while(cur <= n){
            totalNodes += Math.min(n - cur + 1, next - cur);

            next *= 10;
            cur *= 10;
        }

        return (int)totalNodes;
    }
}

这个题目在做很多笔试题中都有非常重要的启发，遇见次数超过三次（腾讯网易阿里），每次都是时间复杂度超了，实际上是一种很灵活的解法，我之前考虑用BFS或者DFS都是比较蠢的方式。

class Solution {
    public int getKthMagicNumber(int k) {
        int []dp=new int[k];int p1=0,p2=0,p3=0;dp[0]=1;
        for(int i=1;i<k;i++){
            int v1=dp[p1]*3,v2=dp[p2]*5,v3=dp[p3]*7;         
            dp[i] = Math.min(v1, Math.min(v2,v3));           
            if(dp[i]==v1)p1++;
            if(dp[i]==v2)p2++;
            if(dp[i]==v3)p3++;//步进+去重 
        }
        return dp[k-1];
    }
}