2021届bilibili笔试2020-08-13场

2021届bilibili笔试2020-08-13场

八月 13, 2020

一堆选择加上三道算法，选择题忽略

1.给出四个数，判断能不能满足24点

暴力枚举所有情况就能通过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Soltion{
public boolean Game24Points (int[] arr) {
        // write code here
        dfs(0,arr,0);
        return flag;
    }
    boolean flag = false;
    public void dfs(int index,int[] arr,int num) {
        if (index > arr.length - 1 || flag) {
            if (num == 24) {
                flag = true;
            }
            return;
        }
        int r = arr[index];

        for (int i = 0; i < 4; i++) {
            if (i == 0) {
                dfs(index + 1,arr,num + r);
            } else if (i == 1) {
                dfs(index + 1,arr,num - r);
            } else if (i == 2) {
                dfs(index + 1,arr,num * r);
            } else if (i == 3 && r != 0) {
                dfs(index + 1,arr,num / r);
            }
        }

    }
}

2.判断括号是否满足条件，括号有三种：（）{}[]，不分优先级

经典栈应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Solution{
//判断字符串是否有效，()[]{}
    public boolean IsValidExp (String s) {
        if (s == null || s.length() == 0) {
            return true;
        }
        // write code here
        Stack<Character> stack = new Stack<>();
        int i = 0;
        int l = s.length();
        while (i < l) {
            char c = s.charAt(i);
            char out;
            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                if (c == ')') {
                    out = stack.pop();
                    if (out == '[' || out == '{') {
                        return false;
                    }
                } else if (c == ']') {
                    out = stack.pop();
                    if (out == '(' || out == '{') {
                        return false;
                    }
                } else if (c == '}') {
                    out = stack.pop();
                    if (out == '(' || out == '[') {
                        return false;
                    }
                }

            }
            i++;

        }
        return stack.isEmpty();
    }
}

3.找零问题，最少找多少硬币

解法1贪心：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution{
public int GetCoinCount (int N) {
        //dp
        // write code here
        int sub = 1024 - N;
        int res = 0;
        res += sub/64;
        sub %= 64;
        res += sub/16;
        sub %= 16;
        res += sub/4;
        sub %= 4;
        res += sub/1;
        return res;
}
}

解法2动态规划：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Solution{
public int GetCoinCount (int N) {
        //dp
        // write code here
        int sub = 1024 - N;
        if (sub == 0) {
            return 0;
        }
        int[] dp = new int[sub + 1];
        dp[1] = 1;
        if (sub >= 4) {
            dp[4] = 1;
        }
        if (sub >= 16) {
            dp[16] = 1;
        }
        if (sub >= 64) {
            dp[64] = 1;
        }
        for (int i = 2; i <= sub; i++) {
            if (i == 4 || i == 16 || i == 64) {
                continue;
            }
            if (i <= 1) {
                dp[i] = 1;
            } else if (i < 4) {
                dp[i] = dp[i - 1] + 1;
            } else if (i < 16) {
                dp[i] = Math.min(dp[i - 1],dp[i - 4]) + 1;
            } else if (i < 64) {
                dp[i] = Math.min(Math.min(dp[i - 1],dp[i - 4]),dp[i - 16]) + 1;
            } else {
                dp[i] = Math.min(Math.min(Math.min(dp[i - 1],dp[i - 4]),dp[i - 16]),dp[i - 64]) + 1;
            }
        }

        //System.out.println("====");
        //System.out.println(Arrays.toString(dp));
        //System.out.println("====");
        return dp[sub];
}
}

解法3，dfs加上备忘录：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Solution{
	public int GetCoinCount (int N) {
        
        //dp
        // write code here
        int sub = 1024 - N;
        coinDfs(sub,0);
        return min;
     }
	private HashMap<Integer,Integer> map = new HashMap<>(1024);
    private int min = 2000;
    public int coinDfs(int coin,int number) {
        if (coin < 0) {
            return 2001;
        }
        if (coin == 0) {
            min = Math.min(number,min);
            return min;
        }
        if (map.containsKey(coin)) {
            min = Math.min(min,number + map.get(coin));
            return min;
        }
        int t = coinDfs(coin - 64,number + 1);
        t = Math.min(t,coinDfs(coin - 16,number + 1));
        t = Math.min(t,coinDfs(coin - 4,number + 1));
        t = Math.min(t,coinDfs(coin - 1,number + 1));
        map.put(coin,t);
        return t;
    }
}

开始第一反应是dp，但是提交不对，后来用备忘录写了一遍，写一半，发现好像就是贪心，然后，贪心交了，就对了，再把备忘录写完交上去也对。然后我想不通为什么dp不对，一对比，发现当n=1024时候，dp[1]那里会越界，所以就出问题了。