Leetcode Weekly Contest 109

933. Number of Recent Calls

https://leetcode.com/problems/number-of-recent-calls/description/
这道题，维护一个队列，每当一个新的时间进来，看看队列头，时间是不是超出了那个范围，超出了就POP，一直到在范围里。

Deque q = new ArrayDeque<>();
    public RecentCounter() {
        
    }
    
    public int ping(int t) {
        
        while(!q.isEmpty() && t - q.peekFirst() > 3000) {
            q.pollFirst();
        }
        q.offerLast(t);
        return q.size();
    }

934. Shortest Bridge

这道题用FLOOD FILL 找到2个岛，分别把坐标存进2个SET。
随后就可以用BFS，找最短路的。这里BFS，和word ladder那道题是一样的。
对所有点，往外扩散，找到这个岛所有一步可达，所有2步可达，所有三步可达。一直到触碰到另外一个岛。

int h;
    int l;
    final int[][] dirs = {{1,0},{0,1},{0,-1},{-1,0}};
    public int shortestBridge(int[][] A) {
        h = A.length;
        l = A[0].length;
        Set st = new HashSet<>();
        Set ed = new HashSet<>();
        
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < l; j++) {
                if (A[i][j] == 0) continue;
                if(st.isEmpty())
                    floodfill(st,A,i,j);
                else
                    floodfill(ed,A,i,j);
            }
        }
        int step = 0;
        
        Set seen = new HashSet<>(st);
        while(true) {
            Set next = new HashSet<>();
            for (int i : st) {
                int y = i / l;
                int x = i % l;
                for(int[] dir : dirs){
                    int ny = y + dir[0];
                    int nx = x + dir[1];
                    int nkey = ny * l + nx;
                    if(ny == h || nx == l || nx < 0 || ny < 0 || seen.contains(nkey)) continue;
                    if(ed.contains(nkey)) return step;
                    seen.add(nkey);
                    next.add(nkey);
                }
            }
            st = next;
            step++;
        }
        
    }
    private void floodfill(Set s, int[][] A, int y, int x) {
        s.add(y * l + x);
        for(int[] dir : dirs){
            int ny = y + dir[0];
            int nx = x + dir[1];
            int nkey = ny * l + nx;
            if(ny == h || nx == l || nx < 0 || ny < 0 || A[ny][nx] == 0 || s.contains(nkey)) continue;
            floodfill(s,A,ny,nx);
        }
    }

935. Knight Dialer

https://leetcode.com/problems/knight-dialer/description/
这道题我看了下，就是每个状态可以转移到另外的一些状态。
根据跳跃规则。那么一共有10个状态。每个状态可以通过一步跳到对应的状态我存进STEP。
随后就是对每一步的这个状态，去映射到下一步的状态。用个DP数组来存。
最后对这种步长的所有走法求和就行。
dp i j 就是 花了 I 步 落在第J个数字上的步数。
那么转移方程，就是根据一个数字 怎么到 另一个数字 都加上去。

public int knightDialer(int N) {
        int[][] dp = new int[N][10];
        int[][] steps = new int[][]{{4,6},{8,6},{7,9},{4,8},{3,9,0},{},{1,7,0},{2,6},{1,3},{2,4}};
        int M = 1000000007;
        Arrays.fill(dp[0],1);
        for (int i = 1; i < N; i++) {
            for (int j = 0; j < 10; j++) {
                for(int k = 0; k < steps[j].length; k++){
                    dp[i][steps[j][k]] = (dp[i][steps[j][k]] + dp[i-1][j])%M;
                }
            }
        }
        long res = 0;
        for (int i = 0; i < 10; i++) {
            res += dp[N-1][i];
        }
        res %= M;
        return (int)res;
    }

936. Stamping The Sequence

https://leetcode.com/problems/stamping-the-sequence/description/
这道题的难点在于逆向思维，以终·为始。如果我们可以一开始就构造好了，随后要把他们全抹掉，记录顺序，顺序也是反着生成的。
首先我们定义每一个位置，都有2种属性，可以直接消的就是字符相等的集合，和没法在这个位置上消的字符。
分别放进MADE, TODO。
然后我们把所有MADE 是满的，也就是TODO 是空的，那些MADE的坐标放进QUEUE。 这个点，都是最后一步覆盖上去的。
然后把这个点，都放进STACK。随后从QUEUE里弹出来用过的坐标。对他们能影响到的其他NODE里，去删除那些NODE里的TODO。 那么一旦有新的NODE，TODO 是空了，又可以放进QUEUE。
最后根据stack 就可以反向生成步骤了。

public int[] movesToStamp(String stamp, String target) {
        int sl = stamp.length();
        int tl = target.length();
        Queue q = new LinkedList<>();
        boolean[] done = new boolean[tl];
        Stack st = new Stack<>();
        List res = new ArrayList<>();
        for (int i = 0; i <= tl - sl; i++) {
            Set made = new HashSet<>();
            Set todo = new HashSet<>();
            for (int j = 0; j < sl; j++) {
                if (stamp.charAt(j) == target.charAt(i + j)) {
                   made.add(i + j); 
                } else {
                    todo.add(i + j);
                }
            }
            Node cur = new Node(made, todo);
            if (todo.isEmpty()) {
                for (int j : made) {
                    if (done[j]) continue;
                    q.offer(j);
                    done[j] = true;
                }
                st.push(i);
            }
            res.add(cur);
        }
        while (!q.isEmpty()) {
            int cur = q.poll();
            for (int i = Math.max(0,cur - sl + 1); i < Math.min(tl - sl + 1,cur + sl); i++) {
                Node newn = res.get(i);
                if (!newn.todo.contains(cur)) continue;
                
                newn.todo.remove(cur);
                if (newn.todo.isEmpty()) {
                    for (int j : newn.made) {
                        if (done[j]) continue;
                        q.offer(j);
                        done[j] = true;
                    }
                    st.push(i);
                }
                
            }
        }
        for(boolean d : done) if(!d) return new int[0];
        int[] ans = new int[st.size()];
        int idx = 0;
        while (!st.isEmpty()) {
            ans[idx++] = st.pop();
        }
        return ans;
    }
    class Node {
        Set made, todo;
        public Node(Set made, Set todo) {
            this.made = made;
            this.todo = todo;
        }
    }